appsignal 3.0.0.beta.1 → 3.0.3

data/lib/appsignal/hooks.rb

@@ -69,6 +69,22 @@ module Appsignal
         text.size > 200 ? "#{text[0...197]}..." : text
       end
     end
+
+    # Alias integration constants that have moved to their own module.
+    def self.const_missing(name)
+      case name
+      when :SidekiqPlugin
+        require "appsignal/integrations/sidekiq"
+        callers = caller
+        Appsignal::Utils::DeprecationMessage.message \
+          "The constant Appsignal::Hooks::SidekiqPlugin has been deprecated. " \
+          "Please update the constant name to Appsignal::Integrations::SidekiqMiddleware " \
+          "in the following file to remove this message.\n#{callers.first}"
+        Appsignal::Integrations::SidekiqMiddleware
+      else
+        super
+      end
+    end
   end
 end
 

data/lib/appsignal/hooks/action_cable.rb

@@ -25,7 +25,11 @@ module Appsignal
       def install_callbacks
         ActionCable::Channel::Base.set_callback :subscribe, :around, :prepend => true do |channel, inner|
           # The request is only the original websocket request
-          env = channel.connection.env
+          connection = channel.connection
+          # #env is not available on the Rails ConnectionStub class used in the
+          # Rails app test suite. If we call `#env` it causes an error to occur
+          # in apps' test suites.
+          env = connection.respond_to?(:env) ? connection.env : {}
           request = ActionDispatch::Request.new(env)
           env[Appsignal::Hooks::ActionCableHook::REQUEST_ID] ||=
             request.request_id || SecureRandom.uuid
@@ -53,7 +57,11 @@ module Appsignal
 
         ActionCable::Channel::Base.set_callback :unsubscribe, :around, :prepend => true do |channel, inner|
           # The request is only the original websocket request
-          env = channel.connection.env
+          connection = channel.connection
+          # #env is not available on the Rails ConnectionStub class used in the
+          # Rails app test suite. If we call `#env` it causes an error to occur
+          # in apps' test suites.
+          env = connection.respond_to?(:env) ? connection.env : {}
           request = ActionDispatch::Request.new(env)
           env[Appsignal::Hooks::ActionCableHook::REQUEST_ID] ||=
             request.request_id || SecureRandom.uuid

data/lib/appsignal/hooks/sidekiq.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require "yaml"
-
 module Appsignal
   class Hooks
     class SidekiqHook < Appsignal::Hooks::Hook
@@ -12,153 +10,22 @@ module Appsignal
       end
 
       def install
+        require "appsignal/integrations/sidekiq"
         Appsignal::Minutely.probes.register :sidekiq, Appsignal::Probes::SidekiqProbe
 
         ::Sidekiq.configure_server do |config|
-          config.server_middleware do |chain|
-            chain.add Appsignal::Hooks::SidekiqPlugin
-          end
-        end
-      end
-    end
-
-    # @api private
-    class SidekiqPlugin # rubocop:disable Metrics/ClassLength
-      include Appsignal::Hooks::Helpers
-
-      EXCLUDED_JOB_KEYS = %w[
-        args backtrace class created_at enqueued_at error_backtrace error_class
-        error_message failed_at jid retried_at retry wrapped
-      ].freeze
-
-      def call(_worker, item, _queue)
-        job_status = nil
-        transaction = Appsignal::Transaction.create(
-          item["jid"],
-          Appsignal::Transaction::BACKGROUND_JOB,
-          Appsignal::Transaction::GenericRequest.new(
-            :queue_start => item["enqueued_at"]
-          )
-        )
-
-        Appsignal.instrument "perform_job.sidekiq" do
-          begin
-            yield
-          rescue Exception => exception # rubocop:disable Lint/RescueException
-            job_status = :failed
-            transaction.set_error(exception)
-            raise exception
-          end
-        end
-      ensure
-        if transaction
-          transaction.set_action_if_nil(formatted_action_name(item))
-
-          params = filtered_arguments(item)
-          transaction.params = params if params
-
-          formatted_metadata(item).each do |key, value|
-            transaction.set_metadata key, value
-          end
-          transaction.set_http_or_background_queue_start
-          Appsignal::Transaction.complete_current!
-          queue = item["queue"] || "unknown"
-          if job_status
-            increment_counter "queue_job_count", 1,
-              :queue => queue,
-              :status => job_status
-          end
-          increment_counter "queue_job_count", 1,
-            :queue => queue,
-            :status => :processed
-        end
-      end
-
-      private
-
-      def increment_counter(key, value, tags = {})
-        Appsignal.increment_counter "sidekiq_#{key}", value, tags
-      end
+          config.error_handlers << \
+            Appsignal::Integrations::SidekiqErrorHandler.new
 
-      def formatted_action_name(job)
-        sidekiq_action_name = parse_action_name(job)
-        return unless sidekiq_action_name
-
-        complete_action = sidekiq_action_name =~ /\.|#/
-        return sidekiq_action_name if complete_action
-
-        "#{sidekiq_action_name}#perform"
-      end
-
-      def filtered_arguments(job)
-        arguments = parse_arguments(job)
-        return unless arguments
-
-        Appsignal::Utils::HashSanitizer.sanitize(
-          arguments,
-          Appsignal.config[:filter_parameters]
-        )
-      end
-
-      def formatted_metadata(item)
-        {}.tap do |hash|
-          (item || {}).each do |key, value|
-            next if EXCLUDED_JOB_KEYS.include?(key)
-
-            hash[key] = truncate(string_or_inspect(value))
-          end
-        end
-      end
-
-      # Based on: https://github.com/mperham/sidekiq/blob/63ee43353bd3b753beb0233f64865e658abeb1c3/lib/sidekiq/api.rb#L316-L334
-      def parse_action_name(job)
-        args = job.fetch("args", [])
-        job_class = job["class"]
-        case job_class
-        when "Sidekiq::Extensions::DelayedModel"
-          safe_load(args[0], job_class) do |target, method, _|
-            "#{target.class}##{method}"
-          end
-        when /\ASidekiq::Extensions::Delayed/
-          safe_load(args[0], job_class) do |target, method, _|
-            "#{target}.#{method}"
-          end
-        else
-          job_class
-        end
-      end
-
-      # Based on: https://github.com/mperham/sidekiq/blob/63ee43353bd3b753beb0233f64865e658abeb1c3/lib/sidekiq/api.rb#L336-L358
-      def parse_arguments(job)
-        args = job.fetch("args", [])
-        case job["class"]
-        when /\ASidekiq::Extensions::Delayed/
-          safe_load(args[0], args) do |_, _, arg|
-            arg
-          end
-        when "ActiveJob::QueueAdapters::SidekiqAdapter::JobWrapper"
-          nil # Set in the ActiveJob integration
-        else
-          # Sidekiq Enterprise argument encryption.
-          # More information: https://github.com/mperham/sidekiq/wiki/Ent-Encryption
-          if job["encrypt".freeze]
-            # No point in showing 150+ bytes of random garbage
-            args[-1] = "[encrypted data]".freeze
+          config.server_middleware do |chain|
+            if chain.respond_to? :prepend
+              chain.prepend Appsignal::Integrations::SidekiqMiddleware
+            else
+              chain.add Appsignal::Integrations::SidekiqMiddleware
+            end
           end
-          args
         end
       end
-
-      # Based on: https://github.com/mperham/sidekiq/blob/63ee43353bd3b753beb0233f64865e658abeb1c3/lib/sidekiq/api.rb#L403-L412
-      def safe_load(content, default)
-        yield(*YAML.load(content))
-      rescue => error
-        # Sidekiq issue #1761: in dev mode, it's possible to have jobs enqueued
-        # which haven't been loaded into memory yet so the YAML can't be
-        # loaded.
-        Appsignal.logger.warn "Unable to load YAML: #{error.message}"
-        default
-      end
     end
   end
 end

data/lib/appsignal/integrations/object.rb

@@ -5,56 +5,34 @@ if defined?(Appsignal)
 end
 
 class Object
-  if Appsignal::System.ruby_2_7_or_newer?
-    def self.appsignal_instrument_class_method(method_name, options = {})
-      singleton_class.send \
-        :alias_method, "appsignal_uninstrumented_#{method_name}", method_name
-      singleton_class.send(:define_method, method_name) do |*args, **kwargs, &block|
-        name = options.fetch(:name) do
-          "#{method_name}.class_method.#{appsignal_reverse_class_name}.other"
-        end
-        Appsignal.instrument name do
-          send "appsignal_uninstrumented_#{method_name}", *args, **kwargs, &block
-        end
+  def self.appsignal_instrument_class_method(method_name, options = {})
+    singleton_class.send \
+      :alias_method, "appsignal_uninstrumented_#{method_name}", method_name
+    singleton_class.send(:define_method, method_name) do |*args, &block|
+      name = options.fetch(:name) do
+        "#{method_name}.class_method.#{appsignal_reverse_class_name}.other"
       end
-    end
-
-    def self.appsignal_instrument_method(method_name, options = {})
-      alias_method "appsignal_uninstrumented_#{method_name}", method_name
-      define_method method_name do |*args, **kwargs, &block|
-        name = options.fetch(:name) do
-          "#{method_name}.#{appsignal_reverse_class_name}.other"
-        end
-        Appsignal.instrument name do
-          send "appsignal_uninstrumented_#{method_name}", *args, **kwargs, &block
-        end
+      Appsignal.instrument name do
+        send "appsignal_uninstrumented_#{method_name}", *args, &block
       end
     end
-  else
-    def self.appsignal_instrument_class_method(method_name, options = {})
-      singleton_class.send \
-        :alias_method, "appsignal_uninstrumented_#{method_name}", method_name
-      singleton_class.send(:define_method, method_name) do |*args, &block|
-        name = options.fetch(:name) do
-          "#{method_name}.class_method.#{appsignal_reverse_class_name}.other"
-        end
-        Appsignal.instrument name do
-          send "appsignal_uninstrumented_#{method_name}", *args, &block
-        end
-      end
+
+    if singleton_class.respond_to?(:ruby2_keywords, true) # rubocop:disable Style/GuardClause
+      singleton_class.send(:ruby2_keywords, method_name)
     end
+  end
 
-    def self.appsignal_instrument_method(method_name, options = {})
-      alias_method "appsignal_uninstrumented_#{method_name}", method_name
-      define_method method_name do |*args, &block|
-        name = options.fetch(:name) do
-          "#{method_name}.#{appsignal_reverse_class_name}.other"
-        end
-        Appsignal.instrument name do
-          send "appsignal_uninstrumented_#{method_name}", *args, &block
-        end
+  def self.appsignal_instrument_method(method_name, options = {})
+    alias_method "appsignal_uninstrumented_#{method_name}", method_name
+    define_method method_name do |*args, &block|
+      name = options.fetch(:name) do
+        "#{method_name}.#{appsignal_reverse_class_name}.other"
+      end
+      Appsignal.instrument name do
+        send "appsignal_uninstrumented_#{method_name}", *args, &block
       end
     end
+    ruby2_keywords method_name if respond_to?(:ruby2_keywords, true)
   end
 
   def self.appsignal_reverse_class_name

data/lib/appsignal/integrations/railtie.rb

@@ -30,10 +30,6 @@ module Appsignal
           Appsignal::Rack::RailsInstrumentation
         )
 
-        if Appsignal.config[:enable_frontend_error_catching]
-          app.middleware.insert_before(Appsignal::Rack::RailsInstrumentation)
-        end
-
         Appsignal.start
       end
     end

data/lib/appsignal/integrations/sidekiq.rb

@@ -0,0 +1,171 @@
+# frozen_string_literal: true
+
+require "yaml"
+
+module Appsignal
+  module Integrations
+    # Error handler for Sidekiq to report errors from jobs and internal Sidekiq
+    # errors.
+    #
+    # @api private
+    class SidekiqErrorHandler
+      def call(exception, sidekiq_context)
+        transaction = Appsignal::Transaction.current
+
+        if transaction.nil_transaction?
+          # Sidekiq error outside of the middleware scope.
+          # Can be a job JSON parse error or some other error happening in
+          # Sidekiq.
+          transaction = Appsignal::Transaction.create(
+            SecureRandom.uuid, # Newly generated job id
+            Appsignal::Transaction::BACKGROUND_JOB,
+            Appsignal::Transaction::GenericRequest.new({})
+          )
+          transaction.set_action_if_nil("SidekiqInternal")
+          transaction.set_metadata("sidekiq_error", sidekiq_context[:context])
+          transaction.params = { :jobstr => sidekiq_context[:jobstr] }
+        end
+
+        transaction.set_error(exception)
+        Appsignal::Transaction.complete_current!
+      end
+    end
+
+    # @api private
+    class SidekiqMiddleware # rubocop:disable Metrics/ClassLength
+      include Appsignal::Hooks::Helpers
+
+      EXCLUDED_JOB_KEYS = %w[
+        args backtrace class created_at enqueued_at error_backtrace error_class
+        error_message failed_at jid retried_at retry wrapped
+      ].freeze
+
+      def call(_worker, item, _queue)
+        job_status = nil
+        transaction = Appsignal::Transaction.create(
+          item["jid"],
+          Appsignal::Transaction::BACKGROUND_JOB,
+          Appsignal::Transaction::GenericRequest.new(
+            :queue_start => item["enqueued_at"]
+          )
+        )
+
+        Appsignal.instrument "perform_job.sidekiq" do
+          yield
+        end
+      rescue Exception => exception # rubocop:disable Lint/RescueException
+        job_status = :failed
+        raise exception
+      ensure
+        if transaction
+          transaction.set_action_if_nil(formatted_action_name(item))
+
+          params = filtered_arguments(item)
+          transaction.params = params if params
+
+          formatted_metadata(item).each do |key, value|
+            transaction.set_metadata key, value
+          end
+          transaction.set_http_or_background_queue_start
+          Appsignal::Transaction.complete_current! unless exception
+
+          queue = item["queue"] || "unknown"
+          if job_status
+            increment_counter "queue_job_count", 1,
+              :queue => queue,
+              :status => job_status
+          end
+          increment_counter "queue_job_count", 1,
+            :queue => queue,
+            :status => :processed
+        end
+      end
+
+      private
+
+      def increment_counter(key, value, tags = {})
+        Appsignal.increment_counter "sidekiq_#{key}", value, tags
+      end
+
+      def formatted_action_name(job)
+        sidekiq_action_name = parse_action_name(job)
+        return unless sidekiq_action_name
+
+        complete_action = sidekiq_action_name =~ /\.|#/
+        return sidekiq_action_name if complete_action
+
+        "#{sidekiq_action_name}#perform"
+      end
+
+      def filtered_arguments(job)
+        arguments = parse_arguments(job)
+        return unless arguments
+
+        Appsignal::Utils::HashSanitizer.sanitize(
+          arguments,
+          Appsignal.config[:filter_parameters]
+        )
+      end
+
+      def formatted_metadata(item)
+        {}.tap do |hash|
+          (item || {}).each do |key, value|
+            next if EXCLUDED_JOB_KEYS.include?(key)
+
+            hash[key] = truncate(string_or_inspect(value))
+          end
+        end
+      end
+
+      # Based on: https://github.com/mperham/sidekiq/blob/63ee43353bd3b753beb0233f64865e658abeb1c3/lib/sidekiq/api.rb#L316-L334
+      def parse_action_name(job)
+        args = job.fetch("args", [])
+        job_class = job["class"]
+        case job_class
+        when "Sidekiq::Extensions::DelayedModel"
+          safe_load(args[0], job_class) do |target, method, _|
+            "#{target.class}##{method}"
+          end
+        when /\ASidekiq::Extensions::Delayed/
+          safe_load(args[0], job_class) do |target, method, _|
+            "#{target}.#{method}"
+          end
+        else
+          job_class
+        end
+      end
+
+      # Based on: https://github.com/mperham/sidekiq/blob/63ee43353bd3b753beb0233f64865e658abeb1c3/lib/sidekiq/api.rb#L336-L358
+      def parse_arguments(job)
+        args = job.fetch("args", [])
+        case job["class"]
+        when /\ASidekiq::Extensions::Delayed/
+          safe_load(args[0], args) do |_, _, arg|
+            arg
+          end
+        when "ActiveJob::QueueAdapters::SidekiqAdapter::JobWrapper"
+          nil # Set in the ActiveJob integration
+        else
+          # Sidekiq Enterprise argument encryption.
+          # More information: https://github.com/mperham/sidekiq/wiki/Ent-Encryption
+          if job["encrypt".freeze]
+            # No point in showing 150+ bytes of random garbage
+            args[-1] = "[encrypted data]".freeze
+          end
+          args
+        end
+      end
+
+      # Based on: https://github.com/mperham/sidekiq/blob/63ee43353bd3b753beb0233f64865e658abeb1c3/lib/sidekiq/api.rb#L403-L412
+      def safe_load(content, default)
+        yield(*YAML.load(content))
+      rescue => error
+        # Sidekiq issue #1761: in dev mode, it's possible to have jobs enqueued
+        # which haven't been loaded into memory yet so the YAML can't be
+        # loaded.
+        Appsignal.logger.warn "Unable to load YAML: #{error.message}"
+        default
+      end
+    end
+  end
+end