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

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/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

data/lib/appsignal/integrations/net_http.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Appsignal
+  module Integrations
+    module NetHttpIntegration
+      def request(request, body = nil, &block)
+        Appsignal.instrument(
+          "request.net_http",
+          "#{request.method} #{use_ssl? ? "https" : "http"}://#{request["host"] || address}"
+        ) do
+          super
+        end
+      end
+    end
+  end
+end

data/lib/appsignal/integrations/object.rb

@@ -4,8 +4,65 @@ if defined?(Appsignal)
   Appsignal::Environment.report_enabled("object_instrumentation")
 end
 
-if RUBY_VERSION < "2.0"
-  require "appsignal/integrations/object_ruby_19"
-else
-  require "appsignal/integrations/object_ruby_modern"
+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
+      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
+      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
+    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
+    end
+  end
+
+  def self.appsignal_reverse_class_name
+    return "AnonymousClass" unless name
+    name.split("::").reverse.join(".")
+  end
+
+  def appsignal_reverse_class_name
+    self.class.appsignal_reverse_class_name
+  end
 end

data/lib/appsignal/integrations/padrino.rb

@@ -19,13 +19,9 @@ module Appsignal
   end
 end
 
-module Padrino::Routing::InstanceMethods
-  alias route_without_appsignal route!
-
+module Appsignal::Integrations::PadrinoIntegration
   def route!(base = settings, pass_block = nil)
-    if !Appsignal.active? || env["sinatra.static_file"]
-      return route_without_appsignal(base, pass_block)
-    end
+    return super if !Appsignal.active? || env["sinatra.static_file"]
 
     transaction = Appsignal::Transaction.create(
       SecureRandom.uuid,
@@ -34,7 +30,7 @@ module Padrino::Routing::InstanceMethods
     )
     begin
       Appsignal.instrument("process_action.padrino") do
-        route_without_appsignal(base, pass_block)
+        super
       end
     rescue Exception => error # rubocop:disable Lint/RescueException
       transaction.set_error(error)
@@ -78,6 +74,8 @@ module Padrino::Routing::InstanceMethods
   end
 end
 
+Padrino::Application.send(:prepend, Appsignal::Integrations::PadrinoIntegration)
+
 Padrino.after_load do
   Appsignal::Integrations::PadrinoPlugin.init
 end