appsignal 2.11.8-java → 3.0.1-java

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,43 @@ 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
+  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
+    end
+    ruby2_keywords method_name if respond_to?(:ruby2_keywords, true)
+  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

data/lib/appsignal/integrations/que.rb

@@ -3,42 +3,35 @@
 module Appsignal
   module Integrations
     module QuePlugin
-      def self.included(base)
-        base.class_eval do
-          def _run_with_appsignal(*)
-            local_attrs = respond_to?(:que_attrs) ? que_attrs : attrs
-            env = {
-              :metadata    => {
-                :id        => local_attrs[:job_id] || local_attrs[:id],
-                :queue     => local_attrs[:queue],
-                :run_at    => local_attrs[:run_at].to_s,
-                :priority  => local_attrs[:priority],
-                :attempts  => local_attrs[:error_count].to_i
-              },
-              :params => local_attrs[:args]
-            }
+      def _run(*)
+        local_attrs = respond_to?(:que_attrs) ? que_attrs : attrs
+        env = {
+          :metadata    => {
+            :id        => local_attrs[:job_id] || local_attrs[:id],
+            :queue     => local_attrs[:queue],
+            :run_at    => local_attrs[:run_at].to_s,
+            :priority  => local_attrs[:priority],
+            :attempts  => local_attrs[:error_count].to_i
+          },
+          :params => local_attrs[:args]
+        }
 
-            request = Appsignal::Transaction::GenericRequest.new(env)
+        request = Appsignal::Transaction::GenericRequest.new(env)
 
-            transaction = Appsignal::Transaction.create(
-              SecureRandom.uuid,
-              Appsignal::Transaction::BACKGROUND_JOB,
-              request
-            )
+        transaction = Appsignal::Transaction.create(
+          SecureRandom.uuid,
+          Appsignal::Transaction::BACKGROUND_JOB,
+          request
+        )
 
-            begin
-              Appsignal.instrument("perform_job.que") { _run_without_appsignal }
-            rescue Exception => error # rubocop:disable Lint/RescueException
-              transaction.set_error(error)
-              raise error
-            ensure
-              transaction.set_action_if_nil "#{local_attrs[:job_class]}#run"
-              Appsignal::Transaction.complete_current!
-            end
-          end
-
-          alias_method :_run_without_appsignal, :_run
-          alias_method :_run, :_run_with_appsignal
+        begin
+          Appsignal.instrument("perform_job.que") { super }
+        rescue Exception => error # rubocop:disable Lint/RescueException
+          transaction.set_error(error)
+          raise error
+        ensure
+          transaction.set_action_if_nil "#{local_attrs[:job_class]}#run"
+          Appsignal::Transaction.complete_current!
         end
       end
     end

data/lib/appsignal/integrations/railtie.rb

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

data/lib/appsignal/integrations/rake.rb

@@ -1,4 +1,28 @@
 # frozen_string_literal: true
 
-# Since version 1.0 requiring this file is not necessary anymore to get
-# Rake integration, it's just here for backward compatibility.
+module Appsignal
+  module Integrations
+    module RakeIntegration
+      def execute(*args)
+        super
+      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
+  end
+end

data/lib/appsignal/integrations/redis.rb

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

data/lib/appsignal/integrations/resque.rb

@@ -3,16 +3,45 @@
 module Appsignal
   module Integrations
     # @api private
-    module ResquePlugin
-      def self.extended(_)
-        callers = caller
-        Appsignal::Utils::DeprecationMessage.message \
-          "The AppSignal ResquePlugin is deprecated and does " \
-          "nothing on extend. In this version of the AppSignal Ruby gem " \
-          "the integration with Resque is automatic on all Resque workers. " \
-          "Please remove the following line from this file to remove this " \
-          "message: extend Appsignal::Integrations::ResquePlugin\n" \
-          "#{callers.first}"
+    module ResqueIntegration
+      def perform
+        transaction = Appsignal::Transaction.create(
+          SecureRandom.uuid,
+          Appsignal::Transaction::BACKGROUND_JOB,
+          Appsignal::Transaction::GenericRequest.new({})
+        )
+
+        Appsignal.instrument "perform.resque" do
+          super
+        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
+
+    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
     end
   end