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

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

@@ -5,27 +5,54 @@ if defined?(Appsignal)
 end
 
 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
+  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
-  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"
+    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
-      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
     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

data/lib/appsignal/integrations/unicorn.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Appsignal
+  module Integrations
+    module UnicornIntegration
+      # 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.
+
+      module Server
+        def worker_loop(worker)
+          Appsignal.forked
+          super
+        end
+      end
+
+      module Worker
+        def close
+          Appsignal.stop("unicorn")
+          super
+        end
+      end
+    end
+  end
+end

data/lib/appsignal/integrations/webmachine.rb

@@ -3,35 +3,33 @@
 module Appsignal
   module Integrations
     # @api private
-    module WebmachinePlugin
-      module FSM
-        def run_with_appsignal
-          transaction = Appsignal::Transaction.create(
-            SecureRandom.uuid,
-            Appsignal::Transaction::HTTP_REQUEST,
-            request,
-            :params_method => :query
-          )
+    module WebmachineIntegration
+      def run
+        transaction = Appsignal::Transaction.create(
+          SecureRandom.uuid,
+          Appsignal::Transaction::HTTP_REQUEST,
+          request,
+          :params_method => :query
+        )
 
-          transaction.set_action_if_nil("#{resource.class.name}##{request.method}")
+        transaction.set_action_if_nil("#{resource.class.name}##{request.method}")
 
-          Appsignal.instrument("process_action.webmachine") do
-            run_without_appsignal
-          end
-
-          Appsignal::Transaction.complete_current!
+        Appsignal.instrument("process_action.webmachine") do
+          super
         end
 
-        private
+        Appsignal::Transaction.complete_current!
+      end
+
+      private
 
-        def handle_exceptions_with_appsignal
-          handle_exceptions_without_appsignal do
-            begin
-              yield
-            rescue Exception => e # rubocop:disable Lint/RescueException
-              Appsignal.set_error(e)
-              raise e
-            end
+      def handle_exceptions
+        super do
+          begin
+            yield
+          rescue Exception => e # rubocop:disable Lint/RescueException
+            Appsignal.set_error(e)
+            raise e
           end
         end
       end