appsignal 2.11.8-java → 3.0.1-java

data/lib/appsignal/hooks.rb

@@ -70,24 +70,17 @@ module Appsignal
       end
     end
 
-    # Alias Probes constants that have moved to their own module in version
-    # 2.11.0.
+    # Alias integration constants that have moved to their own module.
     def self.const_missing(name)
       case name
-      when :SidekiqProbe
+      when :SidekiqPlugin
+        require "appsignal/integrations/sidekiq"
         callers = caller
         Appsignal::Utils::DeprecationMessage.message \
-          "The constant Appsignal::Hooks::SidekiqProbe has been deprecated. " \
-          "Please update the constant name to Appsignal::Probes::SidekiqProbe " \
+          "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::Probes::SidekiqProbe
-      when :PumaProbe
-        callers = caller
-        Appsignal::Utils::DeprecationMessage.message \
-          "The constant Appsignal::Hooks::PumaProbe has been deprecated. " \
-          "Please update the constant name to Appsignal::Probes::PumaProbe " \
-          "in the following file to remove this message.\n#{callers.first}"
-        Appsignal::Probes::PumaProbe
+        Appsignal::Integrations::SidekiqMiddleware
       else
         super
       end

data/lib/appsignal/hooks/action_cable.rb

@@ -14,45 +14,14 @@ module Appsignal
       end
 
       def install
-        patch_perform_action
+        require "appsignal/integrations/action_cable"
+        ActionCable::Channel::Base.send(:prepend, Appsignal::Integrations::ActionCableIntegration)
+
         install_callbacks
       end
 
       private
 
-      def patch_perform_action
-        ActionCable::Channel::Base.class_eval do
-          alias_method :original_perform_action, :perform_action
-
-          def perform_action(*args, &block)
-            # The request is only the original websocket request
-            env = connection.env
-            request = ActionDispatch::Request.new(env)
-            env[Appsignal::Hooks::ActionCableHook::REQUEST_ID] ||=
-              request.request_id || SecureRandom.uuid
-
-            transaction = Appsignal::Transaction.create(
-              env[Appsignal::Hooks::ActionCableHook::REQUEST_ID],
-              Appsignal::Transaction::ACTION_CABLE,
-              request
-            )
-
-            begin
-              original_perform_action(*args, &block)
-            rescue Exception => exception # rubocop:disable Lint/RescueException
-              transaction.set_error(exception)
-              raise exception
-            ensure
-              transaction.params = args.first
-              transaction.set_action_if_nil("#{self.class}##{args.first["action"]}")
-              transaction.set_metadata("path", request.path)
-              transaction.set_metadata("method", "websocket")
-              Appsignal::Transaction.complete_current!
-            end
-          end
-        end
-      end
-
       def install_callbacks
         ActionCable::Channel::Base.set_callback :subscribe, :around, :prepend => true do |channel, inner|
           # The request is only the original websocket request

data/lib/appsignal/hooks/active_support_notifications.rb

@@ -6,8 +6,6 @@ module Appsignal
     class ActiveSupportNotificationsHook < Appsignal::Hooks::Hook
       register :active_support_notifications
 
-      BANG = "!".freeze
-
       def dependencies_present?
         defined?(::ActiveSupport::Notifications::Instrumenter)
       end
@@ -23,100 +21,23 @@ module Appsignal
           end
         end
 
+        require "appsignal/integrations/active_support_notifications"
         instrumenter = ::ActiveSupport::Notifications::Instrumenter
-
+        parent_integration_module = Appsignal::Integrations::ActiveSupportNotificationsIntegration
         if instrumenter.method_defined?(:start) && instrumenter.method_defined?(:finish)
-          install_start_finish
+          install_module(parent_integration_module::StartFinishIntegration)
         else
-          install_instrument
+          install_module(parent_integration_module::InstrumentIntegration)
         end
 
         # rubocop:disable Style/GuardClause
         if instrumenter.method_defined?(:finish_with_state)
-          install_finish_with_state
+          install_module(parent_integration_module::FinishStateIntegration)
         end
       end
 
-      def install_instrument
-        ::ActiveSupport::Notifications::Instrumenter.class_eval do
-          alias instrument_without_appsignal instrument
-
-          def instrument(name, payload = {}, &block)
-            # Events that start with a bang are internal to Rails
-            instrument_this = name[0] != BANG
-
-            Appsignal::Transaction.current.start_event if instrument_this
-
-            instrument_without_appsignal(name, payload, &block)
-          ensure
-            if instrument_this
-              title, body, body_format = Appsignal::EventFormatter.format(name, payload)
-              Appsignal::Transaction.current.finish_event(
-                name.to_s,
-                title,
-                body,
-                body_format
-              )
-            end
-          end
-        end
-      end
-
-      def install_start_finish
-        ::ActiveSupport::Notifications::Instrumenter.class_eval do
-          alias start_without_appsignal start
-
-          def start(name, payload = {})
-            # Events that start with a bang are internal to Rails
-            instrument_this = name[0] != BANG
-
-            Appsignal::Transaction.current.start_event if instrument_this
-
-            start_without_appsignal(name, payload)
-          end
-
-          alias finish_without_appsignal finish
-
-          def finish(name, payload = {})
-            # Events that start with a bang are internal to Rails
-            instrument_this = name[0] != BANG
-
-            if instrument_this
-              title, body, body_format = Appsignal::EventFormatter.format(name, payload)
-              Appsignal::Transaction.current.finish_event(
-                name.to_s,
-                title,
-                body,
-                body_format
-              )
-            end
-
-            finish_without_appsignal(name, payload)
-          end
-        end
-      end
-
-      def install_finish_with_state
-        ::ActiveSupport::Notifications::Instrumenter.class_eval do
-          alias finish_with_state_without_appsignal finish_with_state
-
-          def finish_with_state(listeners_state, name, payload = {})
-            # Events that start with a bang are internal to Rails
-            instrument_this = name[0] != BANG
-
-            if instrument_this
-              title, body, body_format = Appsignal::EventFormatter.format(name, payload)
-              Appsignal::Transaction.current.finish_event(
-                name.to_s,
-                title,
-                body,
-                body_format
-              )
-            end
-
-            finish_with_state_without_appsignal(listeners_state, name, payload)
-          end
-        end
+      def install_module(mod)
+        ::ActiveSupport::Notifications::Instrumenter.send(:prepend, mod)
       end
     end
   end

data/lib/appsignal/hooks/celluloid.rb

@@ -16,16 +16,12 @@ module Appsignal
         # down Celluloid so we're sure our thread does not aggravate this situation.
         # This way we also make sure any outstanding transactions get flushed.
 
-        ::Celluloid.class_eval do
-          class << self
-            alias shutdown_without_appsignal shutdown
-
-            def shutdown
-              Appsignal.stop("celluloid")
-              shutdown_without_appsignal
-            end
+        Celluloid.singleton_class.send(:prepend, Module.new do
+          def shutdown
+            Appsignal.stop("celluloid")
+            super
           end
-        end
+        end)
       end
     end
   end

data/lib/appsignal/hooks/net_http.rb

@@ -13,18 +13,8 @@ module Appsignal
       end
 
       def install
-        Net::HTTP.class_eval do
-          alias request_without_appsignal request
-
-          def request(request, body = nil, &block)
-            Appsignal.instrument(
-              "request.net_http",
-              "#{request.method} #{use_ssl? ? "https" : "http"}://#{request["host"] || address}"
-            ) do
-              request_without_appsignal(request, body, &block)
-            end
-          end
-        end
+        require "appsignal/integrations/net_http"
+        Net::HTTP.send(:prepend, Appsignal::Integrations::NetHttpIntegration)
 
         Appsignal::Environment.report_enabled("net_http")
       end

data/lib/appsignal/hooks/puma.rb

@@ -29,14 +29,12 @@ module Appsignal
 
         return unless defined?(::Puma::Cluster)
         # For clustered mode with multiple workers
-        ::Puma::Cluster.class_eval do
-          alias stop_workers_without_appsignal stop_workers
-
+        ::Puma::Cluster.send(:prepend, Module.new do
           def stop_workers
             Appsignal.stop("puma cluster")
-            stop_workers_without_appsignal
+            super
           end
-        end
+        end)
       end
     end
   end

data/lib/appsignal/hooks/que.rb

@@ -12,7 +12,7 @@ module Appsignal
 
       def install
         require "appsignal/integrations/que"
-        ::Que::Job.send(:include, Appsignal::Integrations::QuePlugin)
+        ::Que::Job.send(:prepend, Appsignal::Integrations::QuePlugin)
 
         ::Que.error_notifier = proc do |error, _job|
           Appsignal::Transaction.current.set_error(error)

data/lib/appsignal/hooks/rake.rb

@@ -11,30 +11,8 @@ module Appsignal
       end
 
       def install
-        ::Rake::Task.class_eval do
-          alias :execute_without_appsignal :execute
-
-          def execute(*args)
-            execute_without_appsignal(*args)
-          rescue Exception => error # rubocop:disable Lint/RescueException
-            # Format given arguments and cast to hash if possible
-            params, _ = args
-            params = params.to_hash if params.respond_to?(:to_hash)
-
-            transaction = Appsignal::Transaction.create(
-              SecureRandom.uuid,
-              Appsignal::Transaction::BACKGROUND_JOB,
-              Appsignal::Transaction::GenericRequest.new(
-                :params => params
-              )
-            )
-            transaction.set_action(name)
-            transaction.set_error(error)
-            transaction.complete
-            Appsignal.stop("rake")
-            raise error
-          end
-        end
+        require "appsignal/integrations/rake"
+        ::Rake::Task.send(:prepend, Appsignal::Integrations::RakeIntegration)
       end
     end
   end

data/lib/appsignal/hooks/redis.rb

@@ -13,19 +13,8 @@ module Appsignal
       end
 
       def install
-        ::Redis::Client.class_eval do
-          alias process_without_appsignal process
-
-          def process(commands, &block)
-            sanitized_commands = commands.map do |command, *args|
-              "#{command}#{" ?" * args.size}"
-            end.join("\n")
-
-            Appsignal.instrument "query.redis", id, sanitized_commands do
-              process_without_appsignal(commands, &block)
-            end
-          end
-        end
+        require "appsignal/integrations/redis"
+        ::Redis::Client.send(:prepend, Appsignal::Integrations::RedisIntegration)
 
         Appsignal::Environment.report_enabled("redis")
       end

data/lib/appsignal/hooks/resque.rb

@@ -11,49 +11,8 @@ module Appsignal
       end
 
       def install
-        Resque::Job.class_eval do
-          alias_method :perform_without_appsignal, :perform
-
-          def perform
-            transaction = Appsignal::Transaction.create(
-              SecureRandom.uuid,
-              Appsignal::Transaction::BACKGROUND_JOB,
-              Appsignal::Transaction::GenericRequest.new({})
-            )
-
-            Appsignal.instrument "perform.resque" do
-              perform_without_appsignal
-            end
-          rescue Exception => exception # rubocop:disable Lint/RescueException
-            transaction.set_error(exception)
-            raise exception
-          ensure
-            if transaction
-              transaction.set_action_if_nil("#{payload["class"]}#perform")
-              args =
-                Appsignal::Utils::HashSanitizer.sanitize(
-                  ResqueHelpers.arguments(payload),
-                  Appsignal.config[:filter_parameters]
-                )
-              transaction.params = args if args
-              transaction.set_tags("queue" => queue)
-
-              Appsignal::Transaction.complete_current!
-            end
-            Appsignal.stop("resque")
-          end
-        end
-      end
-
-      class ResqueHelpers
-        def self.arguments(payload)
-          case payload["class"]
-          when "ActiveJob::QueueAdapters::ResqueAdapter::JobWrapper"
-            nil # Set in the ActiveJob integration
-          else
-            payload["args"]
-          end
-        end
+        require "appsignal/integrations/resque"
+        Resque::Job.send(:prepend, Appsignal::Integrations::ResqueIntegration)
       end
     end
   end

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,157 +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.error_handlers << \
+            Appsignal::Integrations::SidekiqErrorHandler.new
+
           config.server_middleware do |chain|
             if chain.respond_to? :prepend
-              chain.prepend Appsignal::Hooks::SidekiqPlugin
+              chain.prepend Appsignal::Integrations::SidekiqMiddleware
             else
-              chain.add Appsignal::Hooks::SidekiqPlugin
+              chain.add Appsignal::Integrations::SidekiqMiddleware
             end
           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
-
-      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