appsignal 4.8.5 → 4.9.0

data/lib/appsignal/extension.rb

@@ -84,7 +84,7 @@ module Appsignal
     #
     # This class inherits from the {Data} class so that it passes type checks.
     class MockData < Data
-      def initialize(*_args)
+      def initialize(*_args) # rubocop:disable Lint/MissingSuper
         # JRuby extension requirement, as it sends a pointer to the Data object
         # when creating it
       end

data/lib/appsignal/helpers/instrumentation.rb

@@ -138,7 +138,7 @@ module Appsignal
 
         begin
           yield if block_given?
-        rescue Exception => error # rubocop:disable Lint/RescueException
+        rescue Exception => error
           transaction.set_error(error)
           raise error
         ensure
@@ -242,7 +242,7 @@ module Appsignal
 
         transaction.complete
       end
-      alias :send_exception :send_error
+      alias send_exception send_error
 
       # Set an error on the current transaction.
       #
@@ -305,8 +305,8 @@ module Appsignal
         transaction.set_error(exception)
         yield transaction if block_given?
       end
-      alias :set_exception :set_error
-      alias :add_exception :set_error
+      alias set_exception set_error
+      alias add_exception set_error
 
       # Report an error to AppSignal.
       #
@@ -377,7 +377,7 @@ module Appsignal
 
         transaction.complete unless has_parent_transaction
       end
-      alias :report_exception :report_error
+      alias report_exception report_error
 
       # Set a custom action name for the current transaction.
       #
@@ -497,7 +497,7 @@ module Appsignal
         transaction = Appsignal::Transaction.current
         transaction.add_custom_data(data)
       end
-      alias :set_custom_data :add_custom_data
+      alias set_custom_data add_custom_data
 
       # Add tags to the current transaction.
       #
@@ -542,9 +542,9 @@ module Appsignal
         transaction = Appsignal::Transaction.current
         transaction.add_tags(tags)
       end
-      alias :tag_request :add_tags
-      alias :tag_job :add_tags
-      alias :set_tags :add_tags
+      alias tag_request add_tags
+      alias tag_job add_tags
+      alias set_tags add_tags
 
       # Add parameters to the current transaction.
       #
@@ -600,7 +600,7 @@ module Appsignal
         transaction = Appsignal::Transaction.current
         transaction.add_params(params, &block)
       end
-      alias :set_params :add_params
+      alias set_params add_params
 
       # Mark the parameters sample data to be set as an empty value.
       #
@@ -666,7 +666,7 @@ module Appsignal
         transaction = Appsignal::Transaction.current
         transaction.add_session_data(session_data, &block)
       end
-      alias :set_session_data :add_session_data
+      alias set_session_data add_session_data
 
       # Add request headers to the current transaction.
       #
@@ -708,7 +708,7 @@ module Appsignal
         transaction = Appsignal::Transaction.current
         transaction.add_headers(headers, &block)
       end
-      alias :set_headers :add_headers
+      alias set_headers add_headers
 
       # Add breadcrumbs to the transaction.
       #

data/lib/appsignal/hooks/action_cable.rb

@@ -43,7 +43,7 @@ module Appsignal
             Appsignal.instrument "subscribed.action_cable" do
               inner.call
             end
-          rescue Exception => exception # rubocop:disable Lint/RescueException
+          rescue Exception => exception
             transaction.set_error(exception)
             raise exception
           ensure
@@ -79,7 +79,7 @@ module Appsignal
             Appsignal.instrument "unsubscribed.action_cable" do
               inner.call
             end
-          rescue Exception => exception # rubocop:disable Lint/RescueException
+          rescue Exception => exception
             transaction.set_error(exception)
             raise exception
           ensure

data/lib/appsignal/hooks/active_job.rb

@@ -22,13 +22,16 @@ module Appsignal
       end
 
       def dependencies_present?
-        self.class.dependencies_present?
+        self.class.dependencies_present? && Appsignal.config &&
+          Appsignal.config[:instrument_active_job]
       end
 
       def install
         ActiveSupport.on_load(:active_job) do
           ::ActiveJob::Base
             .extend ::Appsignal::Hooks::ActiveJobHook::ActiveJobClassInstrumentation
+          ::ActiveJob::Base
+            .prepend ::Appsignal::Hooks::ActiveJobHook::ActiveJobEnqueueInstrumentation
 
           next unless Appsignal::Hooks::ActiveJobHook.version_7_1_or_higher?
 
@@ -41,8 +44,44 @@ 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) # rubocop:disable Metrics/CyclomaticComplexity
+        def execute(job)
           enqueued_at = job["enqueued_at"]
           queue_start = Time.parse(enqueued_at) if enqueued_at
           queue_time =
@@ -75,7 +114,7 @@ module Appsignal
             transaction.set_action(ActiveJobHelpers.action_name(job))
 
             super
-          rescue Exception => exception # rubocop:disable Lint/RescueException
+          rescue Exception => exception
             job_status = :failed
             transaction_set_error(transaction, exception)
             raise exception

data/lib/appsignal/hooks/delayed_job.rb

@@ -7,7 +7,8 @@ module Appsignal
       register :delayed_job
 
       def dependencies_present?
-        defined?(::Delayed::Plugin)
+        defined?(::Delayed::Plugin) && Appsignal.config &&
+          Appsignal.config[:instrument_delayed_job]
       end
 
       def install

data/lib/appsignal/hooks/excon.rb

@@ -7,7 +7,7 @@ module Appsignal
       register :excon
 
       def dependencies_present?
-        Appsignal.config && defined?(::Excon)
+        Appsignal.config && defined?(::Excon) && Appsignal.config[:instrument_excon]
       end
 
       def install

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.