appsignal 4.8.6-java → 4.9.0-java

data/lib/appsignal/hooks/faraday.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Appsignal
+  class Hooks
+    # @!visibility private
+    class FaradayHook < Appsignal::Hooks::Hook
+      register :faraday
+
+      def dependencies_present?
+        defined?(::Faraday) && Appsignal.config && Appsignal.config[:instrument_faraday]
+      end
+
+      def install
+        require "appsignal/integrations/faraday"
+        ::Faraday::RackBuilder.prepend(Appsignal::Integrations::FaradayRackBuilderPatch)
+
+        Appsignal::Environment.report_enabled("faraday")
+      end
+    end
+  end
+end

data/lib/appsignal/hooks/http.rb

@@ -16,6 +16,8 @@ module Appsignal
 
       def install
         require "appsignal/integrations/http"
+        # `Client#request` takes positional options in http5 and keyword options
+        # in http6.
         integration =
           if self.class.http6_or_higher?
             Appsignal::Integrations::HttpIntegration::KeywordOptions
@@ -23,6 +25,13 @@ module Appsignal
             Appsignal::Integrations::HttpIntegration::HashOptions
           end
         HTTP::Client.prepend integration
+        # In http6 a chained request (`.follow`, `.headers`, ...) goes through
+        # `HTTP::Session#request` instead of `HTTP::Client#request`, so
+        # instrument it too (keyword options). http5 has no Session; chained
+        # requests run through `Client#request` there.
+        if defined?(HTTP::Session)
+          HTTP::Session.prepend Appsignal::Integrations::HttpIntegration::KeywordOptions
+        end
 
         Appsignal::Environment.report_enabled("http_rb")
       end

data/lib/appsignal/hooks/mongo_ruby_driver.rb

@@ -7,7 +7,8 @@ module Appsignal
       register :mongo_ruby_driver
 
       def dependencies_present?
-        defined?(::Mongo::Monitoring::Global)
+        defined?(::Mongo::Monitoring::Global) && Appsignal.config &&
+          Appsignal.config[:instrument_mongo]
       end
 
       def install

data/lib/appsignal/hooks/que.rb

@@ -7,12 +7,18 @@ module Appsignal
       register :que
 
       def dependencies_present?
-        defined?(::Que::Job)
+        defined?(::Que::Job) && Appsignal.config && Appsignal.config[:instrument_que]
       end
 
       def install
         require "appsignal/integrations/que"
         ::Que::Job.prepend Appsignal::Integrations::QuePlugin
+        ::Que::Job.singleton_class.prepend Appsignal::Integrations::QueClientPlugin
+
+        # `bulk_enqueue` exists only on Que 2+; don't define one where it's absent.
+        if ::Que::Job.respond_to?(:bulk_enqueue)
+          ::Que::Job.singleton_class.prepend Appsignal::Integrations::QueBulkClientPlugin
+        end
 
         ::Que.error_notifier = proc do |error, _job|
           Appsignal::Transaction.current.set_error(error)

data/lib/appsignal/hooks/resque.rb

@@ -7,12 +7,16 @@ module Appsignal
       register :resque
 
       def dependencies_present?
-        defined?(::Resque)
+        defined?(::Resque) && Appsignal.config && Appsignal.config[:instrument_resque]
       end
 
       def install
         require "appsignal/integrations/resque"
         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.
+        Resque.singleton_class.prepend Appsignal::Integrations::ResquePushIntegration
       end
     end
   end

data/lib/appsignal/hooks/shoryuken.rb

@@ -7,7 +7,7 @@ module Appsignal
       register :shoryuken
 
       def dependencies_present?
-        defined?(::Shoryuken)
+        defined?(::Shoryuken) && Appsignal.config && Appsignal.config[:instrument_shoryuken]
       end
 
       def install
@@ -17,6 +17,20 @@ module Appsignal
           config.server_middleware do |chain|
             chain.add Appsignal::Integrations::ShoryukenMiddleware
           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.
+          config.client_middleware do |chain|
+            chain.add Appsignal::Integrations::ShoryukenClientMiddleware
+          end
+        end
+
+        ::Shoryuken.configure_client do |config|
+          config.client_middleware do |chain|
+            chain.add Appsignal::Integrations::ShoryukenClientMiddleware
+          end
         end
       end
     end

data/lib/appsignal/hooks/sidekiq.rb

@@ -20,7 +20,8 @@ module Appsignal
       end
 
       def dependencies_present?
-        self.class.dependencies_present?
+        self.class.dependencies_present? && Appsignal.config &&
+          Appsignal.config[:instrument_sidekiq]
       end
 
       def install
@@ -42,6 +43,18 @@ module Appsignal
               chain.add Appsignal::Integrations::SidekiqMiddleware
             end
           end
+
+          # Servers enqueue jobs too, so they need the client middleware that
+          # records the enqueue event.
+          config.client_middleware do |chain|
+            chain.add Appsignal::Integrations::SidekiqClientMiddleware
+          end
+        end
+
+        ::Sidekiq.configure_client do |config|
+          config.client_middleware do |chain|
+            chain.add Appsignal::Integrations::SidekiqClientMiddleware
+          end
         end
       end
     end

data/lib/appsignal/hooks.rb

@@ -85,6 +85,7 @@ require "appsignal/hooks/code_ownership"
 require "appsignal/hooks/delayed_job"
 require "appsignal/hooks/gvl"
 require "appsignal/hooks/dry_monitor"
+require "appsignal/hooks/faraday"
 require "appsignal/hooks/http"
 require "appsignal/hooks/mri"
 require "appsignal/hooks/net_http"

data/lib/appsignal/integrations/action_cable.rb

@@ -15,7 +15,7 @@ module Appsignal
 
         begin
           super
-        rescue Exception => exception # rubocop:disable Lint/RescueException
+        rescue Exception => exception
           transaction.set_error(exception)
           raise exception
         ensure

data/lib/appsignal/integrations/active_support_notifications.rb

@@ -7,16 +7,21 @@ 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)
-          # Events that start with a bang are internal to Rails
-          instrument_this = name[0] != BANG
-          Appsignal::Transaction.current.start_event if instrument_this
+          return unless record_event?(name)
+
+          Appsignal::Transaction.current.start_event
         end
 
         def finish_event(name, payload = {})
-          # Events that start with a bang are internal to Rails
-          instrument_this = name[0] != BANG
-          return unless instrument_this
+          return unless record_event?(name)
 
           title, body, body_format = Appsignal::EventFormatter.format(name, payload)
           Appsignal::Transaction.current.finish_event(
@@ -26,6 +31,14 @@ module Appsignal
             body_format
           )
         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.
+        def record_event?(name)
+          name = name.to_s
+          name[0] != BANG && !SUPPRESSED_EVENT_NAMES.include?(name)
+        end
       end
 
       module InstrumentIntegration

data/lib/appsignal/integrations/delayed_job_plugin.rb

@@ -7,6 +7,10 @@ module Appsignal
       extend Appsignal::Hooks::Helpers
 
       callbacks do |lifecycle|
+        lifecycle.around(:enqueue) do |job, &block|
+          enqueue_with_instrumentation(job, block)
+        end
+
         lifecycle.around(:invoke_job) do |job, &block|
           invoke_with_instrumentation(job, block)
         end
@@ -16,6 +20,37 @@ module Appsignal
         end
       end
 
+      # Records an `enqueue.delayed_job` event so the enqueue shows up under the
+      # active transaction (e.g. when enqueuing from within a web request or
+      # another job). An enqueue with no active transaction is a transparent
+      # pass-through.
+      def self.enqueue_with_instrumentation(job, block)
+        # Under Active Job the enqueue is already recorded as an
+        # `enqueue.active_job` event, so skip recording it again here.
+        if Appsignal::Transaction.current? &&
+            Appsignal::Transaction.current.job_enqueue_events_suppressed?
+          return block.call(job)
+        end
+
+        Appsignal.instrument("enqueue.delayed_job", "enqueue #{enqueue_name(job)} job") do
+          block.call(job)
+        end
+      end
+
+      # Titles the enqueue event after the job. The `appsignal_name` override is
+      # honored verbatim, as it is when naming the perform action. That override
+      # is a full action name, so an enqueue that uses it reads as
+      # `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.
+      def self.enqueue_name(job)
+        payload = job.payload_object
+        appsignal_name = extract_value(payload, :appsignal_name, nil)
+        return appsignal_name if appsignal_name.is_a?(String)
+
+        job.name
+      end
+
       def self.invoke_with_instrumentation(job, block)
         transaction =
           Appsignal::Transaction.create(Appsignal::Transaction::BACKGROUND_JOB)
@@ -24,7 +59,7 @@ module Appsignal
           Appsignal.instrument("perform_job.delayed_job") do
             block.call(job)
           end
-        rescue Exception => error # rubocop:disable Lint/RescueException
+        rescue Exception => error
           transaction.set_error(error)
           raise
         ensure
@@ -63,6 +98,7 @@ module Appsignal
         "#{default_name}#perform"
       end
 
+      # rubocop:disable Style/OptionalBooleanParameter
       def self.extract_value(object_or_hash, field, default_value = nil, convert_to_s = false)
         value = nil
 
@@ -87,6 +123,7 @@ module Appsignal
           value
         end
       end
+      # rubocop:enable Style/OptionalBooleanParameter
     end
   end
 end

data/lib/appsignal/integrations/excon.rb

@@ -5,6 +5,14 @@ module Appsignal
     # @!visibility private
     module ExconIntegration
       def self.instrument(name, data, &block)
+        # Skip when an outer HTTP client integration (Faraday) already records
+        # this request, so it isn't instrumented twice. Excon calls the
+        # instrumentor for block-less notifications too, hence the `block_given?`.
+        if Appsignal::Transaction.current? &&
+            Appsignal::Transaction.current.http_client_events_suppressed?
+          return block_given? ? yield : nil
+        end
+
         namespace, *event = name.split(".")
         rails_name = [event, namespace].flatten.join(".")
 

data/lib/appsignal/integrations/faraday.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+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.
+    #
+    # @!visibility private
+    class FaradayMiddleware < ::Faraday::Middleware
+      def call(env)
+        http_method = env[:method].to_s.upcase
+        uri = env[:url]
+        # Title only, no body: the path is left out so the event matches
+        # Net::HTTP's (scheme and host only), keeping paths out of event titles.
+        Appsignal.instrument(
+          "request.faraday",
+          "#{http_method} #{uri.scheme}://#{uri.host}"
+        ) do
+          # 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
+        end
+      end
+    end
+
+    # Prepended to `Faraday::RackBuilder#adapter`, the single point every
+    # connection passes through as it finishes building its middleware stack.
+    # Faraday has no global default middleware stack (unlike Excon), so patching
+    # 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.
+    #
+    # @!visibility private
+    module FaradayRackBuilderPatch
+      def adapter(*)
+        use(FaradayMiddleware) unless handlers.any? { |handler| handler.klass == FaradayMiddleware }
+        super
+      end
+    end
+  end
+end

data/lib/appsignal/integrations/http.rb

@@ -12,6 +12,15 @@ module Appsignal
         Appsignal.instrument("request.http_rb", "#{verb.upcase} #{request_uri}", &block)
       end
 
+      # The event is recorded at the request boundary, so a redirected request
+      # stays a single `request.http_rb` event spanning every hop. That boundary
+      # lives in more than one place: a bare request runs through
+      # `HTTP::Client#request`, but in http6 a chained request (`.follow`,
+      # `.headers`, `.timeout`, ...) runs through `HTTP::Session#request`
+      # instead, which never touches `Client#request`. The hook prepends one of
+      # these onto each. `Client#request` takes positional options in http5 and
+      # keyword options in http6; `Session#request` (http6 only) takes keyword
+      # options.
       module HashOptions
         def request(verb, uri, opts = {})
           HttpIntegration.instrument(verb, uri) { super }

data/lib/appsignal/integrations/mongo_ruby_driver.rb

@@ -46,11 +46,13 @@ module Appsignal
         store   = transaction.store("mongo_driver")
         command = store.delete(event.request_id) || {}
 
-        # Finish the event in the extension.
+        # 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.
         transaction.finish_event(
           "query.mongodb",
           "#{event.command_name} | #{event.database_name} | #{result}",
-          Appsignal::Utils::Data.generate(command),
+          Appsignal::Utils::JSON.generate(command),
           Appsignal::EventFormatter::DEFAULT
         )
 

data/lib/appsignal/integrations/net_http.rb

@@ -5,6 +5,13 @@ module Appsignal
     # @!visibility private
     module NetHttpIntegration
       def request(request, body = nil, &block)
+        # Skip when an outer HTTP client integration (Faraday) already records
+        # this request, so it isn't instrumented twice.
+        if Appsignal::Transaction.current? &&
+            Appsignal::Transaction.current.http_client_events_suppressed?
+          return super
+        end
+
         Appsignal.instrument(
           "request.net_http",
           "#{request.method} #{use_ssl? ? "https" : "http"}://#{request["host"] || address}"

data/lib/appsignal/integrations/object.rb

@@ -27,9 +27,9 @@ class Object
       end
     end
 
-    if singleton_class.respond_to?(:ruby2_keywords, true) # rubocop:disable Style/GuardClause
-      singleton_class.send(:ruby2_keywords, method_name)
-    end
+    return unless singleton_class.respond_to?(:ruby2_keywords, true)
+
+    singleton_class.send(:ruby2_keywords, method_name)
   end
 
   # Instruments an instance method with AppSignal monitoring.

data/lib/appsignal/integrations/que.rb

@@ -10,7 +10,7 @@ module Appsignal
 
         begin
           Appsignal.instrument("perform_job.que") { super }
-        rescue Exception => error # rubocop:disable Lint/RescueException
+        rescue Exception => error
           transaction.set_error(error)
           raise error
         ensure
@@ -34,5 +34,72 @@ module Appsignal
         end
       end
     end
+
+    # @!visibility private
+    #
+    # Prepended to `Que::Job`'s singleton so it records each enqueue as an
+    # `enqueue.que` event under the active transaction. Like all AppSignal
+    # events, it only records when there's an active transaction (e.g. enqueuing
+    # from within a web request or another job); otherwise it's a transparent
+    # pass-through.
+    module QueClientPlugin
+      def enqueue(*_args, job_options: {}, **_rest)
+        # Inside a `bulk_enqueue` block the batch is recorded once by the
+        # `bulk_enqueue` wrapper, so each inner enqueue is a pass-through to
+        # avoid recording an event per job.
+        return super if Thread.current[:appsignal_que_bulk_enqueue]
+
+        # Under Active Job the enqueue is already recorded as an
+        # `enqueue.active_job` event, so skip recording it again here.
+        return super if Appsignal::Transaction.current? &&
+          Appsignal::Transaction.current.job_enqueue_events_suppressed?
+
+        # Resolve the job class the way Que does: an explicit `:job_class`, else
+        # the class `enqueue` was called on.
+        title = "enqueue #{job_options[:job_class] || name} job"
+        Appsignal.instrument("enqueue.que", title) { super }
+      end
+    end
+
+    # @!visibility private
+    #
+    # `bulk_enqueue` exists only on Que 2+, so this lives in its own module that
+    # the hook prepends only when Que has the method -- otherwise we'd define a
+    # `bulk_enqueue` on Que versions that have none. The whole batch records a
+    # single `bulk_enqueue.que` event; the inner enqueues are pass-throughs.
+    module QueBulkClientPlugin
+      def bulk_enqueue(*_args, job_options: {}, **_rest)
+        # Under Active Job the enqueue is already recorded as an
+        # `enqueue.active_job` event, so skip recording it again here.
+        return super if Appsignal::Transaction.current? &&
+          Appsignal::Transaction.current.job_enqueue_events_suppressed?
+
+        Appsignal.instrument("bulk_enqueue.que", bulk_enqueue_title(job_options)) do
+          # Flag the batch so the enqueues this block triggers pass through
+          # without recording, without reading Que's internal bulk state.
+          was_bulk = Thread.current[:appsignal_que_bulk_enqueue]
+          Thread.current[:appsignal_que_bulk_enqueue] = true
+          begin
+            super
+          ensure
+            Thread.current[:appsignal_que_bulk_enqueue] = was_bulk
+          end
+        end
+      end
+
+      private
+
+      # The batch's job class is known up front only from an explicit
+      # `:job_class` or when `bulk_enqueue` is called on a concrete subclass;
+      # called on `Que::Job` itself the class isn't known until the inner
+      # enqueues run, so the title is left class-less.
+      def bulk_enqueue_title(job_options)
+        job_class = job_options[:job_class]
+        job_class ||= name unless equal?(::Que::Job)
+        return "bulk enqueue jobs" unless job_class
+
+        "bulk enqueue #{job_class} jobs"
+      end
+    end
   end
 end

data/lib/appsignal/integrations/rake.rb

@@ -25,7 +25,7 @@ module Appsignal
           Appsignal.instrument "task.rake" do
             super
           end
-        rescue Exception => error # rubocop:disable Lint/RescueException
+        rescue Exception => error
           Appsignal::Integrations::RakeIntegrationHelper.register_at_exit_hook
           unless RakeIntegration.ignored_error?(error)
             transaction ||= _appsignal_create_transaction

data/lib/appsignal/integrations/resque.rb

@@ -10,7 +10,7 @@ module Appsignal
         Appsignal.instrument "perform.resque" do
           super
         end
-      rescue Exception => exception # rubocop:disable Lint/RescueException
+      rescue Exception => exception
         transaction.set_error(exception)
         raise exception
       ensure
@@ -25,6 +25,25 @@ module Appsignal
       end
     end
 
+    # Wraps `Resque.push` to record an `enqueue.resque` event so the enqueue
+    # shows up under the active transaction.
+    #
+    # Like all AppSignal events, this only records when there's an active
+    # transaction (e.g. enqueuing from within a web request or another job).
+    # An enqueue with no transaction is a transparent pass-through.
+    #
+    # @!visibility private
+    module ResquePushIntegration
+      def push(_queue, item)
+        # Under Active Job the enqueue is already recorded as an
+        # `enqueue.active_job` event, so skip recording it again here.
+        return super if Appsignal::Transaction.current? &&
+          Appsignal::Transaction.current.job_enqueue_events_suppressed?
+
+        Appsignal.instrument("enqueue.resque", "enqueue #{item["class"]} job") { super }
+      end
+    end
+
     # @!visibility private
     class ResqueHelpers
       def self.arguments(payload)

data/lib/appsignal/integrations/shoryuken.rb

@@ -8,7 +8,7 @@ module Appsignal
         transaction = Appsignal::Transaction.create(Appsignal::Transaction::BACKGROUND_JOB)
 
         Appsignal.instrument("perform_job.shoryuken", &block)
-      rescue Exception => error # rubocop:disable Lint/RescueException
+      rescue Exception => error
         transaction.set_error(error)
         raise
       ensure
@@ -71,5 +71,37 @@ module Appsignal
         end
       end
     end
+
+    # Shoryuken client middleware that records an `enqueue.shoryuken` event so
+    # the enqueue shows up under the active transaction.
+    #
+    # Like all AppSignal events, this only records when there's an active
+    # transaction (e.g. enqueuing from within a web request or another job). An
+    # enqueue with no transaction is a transparent pass-through.
+    #
+    # @!visibility private
+    class ShoryukenClientMiddleware
+      def call(options, &block)
+        # Under Active Job the enqueue is already recorded as an
+        # `enqueue.active_job` event, so skip recording it again here.
+        return yield if Appsignal::Transaction.current? &&
+          Appsignal::Transaction.current.job_enqueue_events_suppressed?
+
+        Appsignal.instrument("enqueue.shoryuken", enqueue_title(options), &block)
+      end
+
+      private
+
+      # Enqueues through a Shoryuken worker carry the worker class in the
+      # `shoryuken_class` message attribute. Raw `send_message` enqueues don't,
+      # so there's no worker class to name -- fall back to the queue instead.
+      def enqueue_title(options)
+        worker_class = options.dig(:message_attributes, "shoryuken_class", :string_value)
+        return "enqueue #{worker_class} job" if worker_class
+
+        queue = options[:queue_url].to_s.split("/").last
+        "enqueue on #{queue}"
+      end
+    end
   end
 end