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

data/lib/appsignal/integrations/delayed_job_plugin.rb

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

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

data/lib/appsignal/integrations/mongo_ruby_driver.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "json"
+
 module Appsignal
   class Hooks
     # @!visibility private
@@ -19,8 +21,25 @@ module Appsignal
         store                   = transaction.store("mongo_driver")
         store[event.request_id] = command
 
-        # Start this event
-        transaction.start_event
+        # Start this event. The query is an outgoing client call.
+        transaction.start_event(
+          :opentelemetry_kind => :client,
+          :opentelemetry_scope => ["appsignal-ruby/mongo", Appsignal::VERSION]
+        )
+        # Names the datastore this span talks to, which is what the trace
+        # timeline reads to recognize a database call, along with the command
+        # that ran, what it ran against, and the server it went to. Set here,
+        # where the event span it describes is the open one.
+        transaction.add_opentelemetry_attributes(
+          {
+            "db.system.name" => "mongodb",
+            "db.operation.name" => event.command_name,
+            "db.collection.name" => collection_name(event),
+            "db.namespace" => event.database_name,
+            "server.address" => event.address&.host,
+            "server.port" => event.address&.port
+          }.compact
+        )
       end
 
       # Called by Mongo::Monitor when query succeeds
@@ -46,9 +65,29 @@ module Appsignal
         store   = transaction.store("mongo_driver")
         command = store.delete(event.request_id) || {}
 
+        # Say what kind of failure ended the query, which the OpenTelemetry
+        # semantic conventions ask for on a span whose operation failed. The
+        # driver reports a failure by calling us rather than by raising, so this
+        # is the only place it can be read. Set before the event is finished, so
+        # it lands on the query's own span.
+        #
+        # Only a failure event carries a failure, which is what tells the two
+        # apart here.
+        if event.respond_to?(:failure)
+          transaction.add_opentelemetry_attributes(
+            Appsignal::OpenTelemetry::ErrorType.attributes_for(error_name(event.failure))
+          )
+          # MongoDB's own code for the error, which the conventions ask for
+          # whenever the database reported one.
+          transaction.add_opentelemetry_attributes(
+            { "db.response.status_code" => error_code(event.failure) }.compact
+          )
+        end
+
         # Finish the event. The sanitized command is a (nested) Hash; emit it
-        # as a JSON string. The agent serializes structured bodies to JSON
-        # anyway, so this is equivalent output.
+        # as a JSON string so it works with both transaction backends. The
+        # agent serializes structured bodies to JSON anyway, so this is
+        # equivalent output there, and the collector receives a plain string.
         transaction.finish_event(
           "query.mongodb",
           "#{event.command_name} | #{event.database_name} | #{result}",
@@ -63,6 +102,36 @@ module Appsignal
           :database => event.database_name
         )
       end
+
+      private
+
+      # The collection a command worked on. MongoDB puts it in the field named
+      # after the command itself, as in `{ "find" => "users" }`. A command that
+      # works on the database as a whole rather than on one collection has
+      # something else in that field, such as the number 1, so only a String
+      # counts as a collection name.
+      def collection_name(event)
+        return unless event.command.respond_to?(:[])
+
+        collection = event.command[event.command_name]
+        collection if collection.is_a?(String)
+      end
+
+      # MongoDB's own code for an error, which it puts in the `code` field of the
+      # error document it replies with. Reported as a String, which is what the
+      # conventions ask for.
+      def error_code(failure)
+        return unless failure.respond_to?(:[])
+
+        failure["code"]&.to_s
+      end
+
+      # MongoDB names an error in the `codeName` field of the error document it
+      # replies with. A failure the driver never got a document for, such as a
+      # connection that dropped, has no name.
+      def error_name(failure)
+        failure["codeName"] if failure.respond_to?(:[])
+      end
     end
   end
 end

data/lib/appsignal/integrations/net_http.rb

@@ -14,9 +14,38 @@ module Appsignal
 
         Appsignal.instrument(
           "request.net_http",
-          "#{request.method} #{use_ssl? ? "https" : "http"}://#{request["host"] || address}"
+          "#{request.method} #{use_ssl? ? "https" : "http"}://#{request["host"] || address}",
+          :opentelemetry_kind => :client,
+          :opentelemetry_scope => ["appsignal-ruby/net_http", Appsignal::VERSION]
         ) do
-          super
+          # 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.
+          #
+          # The client's own `address` and `port` name the host being called.
+          # The request's `path` is a request target, so it can carry a query
+          # string, which the attribute builder cuts off.
+          Appsignal::Transaction.current.add_opentelemetry_attributes(
+            Appsignal::OpenTelemetry::HttpClientRequest.attributes_for(
+              :method => request.method,
+              :scheme => use_ssl? ? "https" : "http",
+              :host => address,
+              :port => port,
+              :path => request.path
+            )
+          )
+          # Write trace context onto the outgoing request so the called service
+          # joins this trace. No-op outside collector mode. The request object
+          # is a valid carrier (it responds to `[]=`).
+          Appsignal::OpenTelemetry.inject_context(request)
+          # 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.
+          super.tap do |response|
+            Appsignal::Transaction.current.add_opentelemetry_attributes(
+              Appsignal::OpenTelemetry::HttpResponse.attributes_for(response&.code)
+            )
+          end
         end
       end
     end

data/lib/appsignal/integrations/puma.rb

@@ -13,7 +13,10 @@ module Appsignal
           end
 
         unless PumaServerHelper.ignored_error?(error)
-          Appsignal.report_error(error) do |transaction|
+          Appsignal.report_error(
+            error,
+            :opentelemetry_scope => ["appsignal-ruby/puma", Appsignal::VERSION]
+          ) do |transaction|
             Appsignal::Rack::ApplyRackRequest
               .new(::Rack::Request.new(env))
               .apply_to(transaction)