appsignal 2.11.9-java → 3.0.0.beta.1-java

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

@@ -16,11 +16,7 @@ module Appsignal
 
         ::Sidekiq.configure_server do |config|
           config.server_middleware do |chain|
-            if chain.respond_to? :prepend
-              chain.prepend Appsignal::Hooks::SidekiqPlugin
-            else
-              chain.add Appsignal::Hooks::SidekiqPlugin
-            end
+            chain.add Appsignal::Hooks::SidekiqPlugin
           end
         end
       end

data/lib/appsignal/hooks/unicorn.rb

@@ -12,30 +12,9 @@ module Appsignal
       end
 
       def install
-        # Make sure that appsignal is started and the last transaction
-        # in a worker gets flushed.
-        #
-        # We'd love to be able to hook this into Unicorn in a less
-        # intrusive way, but this is the best we can do given the
-        # options we have.
-
-        ::Unicorn::HttpServer.class_eval do
-          alias worker_loop_without_appsignal worker_loop
-
-          def worker_loop(worker)
-            Appsignal.forked
-            worker_loop_without_appsignal(worker)
-          end
-        end
-
-        ::Unicorn::Worker.class_eval do
-          alias close_without_appsignal close
-
-          def close
-            Appsignal.stop("unicorn")
-            close_without_appsignal
-          end
-        end
+        require "appsignal/integrations/unicorn"
+        ::Unicorn::HttpServer.send(:prepend, Appsignal::Integrations::UnicornIntegration::Server)
+        ::Unicorn::Worker.send(:prepend, Appsignal::Integrations::UnicornIntegration::Worker)
       end
     end
   end

data/lib/appsignal/hooks/webmachine.rb

@@ -12,13 +12,7 @@ module Appsignal
 
       def install
         require "appsignal/integrations/webmachine"
-        ::Webmachine::Decision::FSM.class_eval do
-          include Appsignal::Integrations::WebmachinePlugin::FSM
-          alias run_without_appsignal run
-          alias run run_with_appsignal
-          alias handle_exceptions_without_appsignal handle_exceptions
-          alias handle_exceptions handle_exceptions_with_appsignal
-        end
+        ::Webmachine::Decision::FSM.send(:prepend, Appsignal::Integrations::WebmachineIntegration)
       end
     end
   end

data/lib/appsignal/integrations/action_cable.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Appsignal
+  module Integrations
+    module ActionCableIntegration
+      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
+          super
+        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
+end

data/lib/appsignal/integrations/active_support_notifications.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module Appsignal
+  module Integrations
+    module ActiveSupportNotificationsIntegration
+      BANG = "!".freeze
+
+      module InstrumentIntegration
+        def instrument(name, payload = {}, &block)
+          # Events that start with a bang are internal to Rails
+          instrument_this = name[0] != ActiveSupportNotificationsIntegration::BANG
+
+          Appsignal::Transaction.current.start_event if instrument_this
+
+          super
+        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
+
+      module StartFinishIntegration
+        def start(name, payload = {})
+          # Events that start with a bang are internal to Rails
+          instrument_this = name[0] != ActiveSupportNotificationsIntegration::BANG
+
+          Appsignal::Transaction.current.start_event if instrument_this
+
+          super
+        end
+
+        def finish(name, payload = {})
+          # Events that start with a bang are internal to Rails
+          instrument_this = name[0] != ActiveSupportNotificationsIntegration::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
+
+          super
+        end
+      end
+
+      module FinishStateIntegration
+        def finish_with_state(listeners_state, name, payload = {})
+          # Events that start with a bang are internal to Rails
+          instrument_this = name[0] != ActiveSupportNotificationsIntegration::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
+
+          super
+        end
+      end
+    end
+  end
+end