appsignal 3.10.0-java → 3.12.0-java

data/lib/appsignal/integrations/active_support_notifications.rb

@@ -2,6 +2,7 @@
 
 module Appsignal
   module Integrations
+    # @api private
     module ActiveSupportNotificationsIntegration
       BANG = "!"
 

data/lib/appsignal/integrations/capistrano/capistrano_2_tasks.rb

@@ -1,47 +1,48 @@
 # frozen_string_literal: true
 
 module Appsignal
-  # @todo Move to sub-namespace
-  # @api private
-  class Capistrano
-    def self.tasks(config)
-      config.load do # rubocop:disable Metrics/BlockLength
-        after "deploy", "appsignal:deploy"
-        after "deploy:migrations", "appsignal:deploy"
+  module Integrations
+    # @api private
+    class Capistrano
+      def self.tasks(config)
+        config.load do # rubocop:disable Metrics/BlockLength
+          after "deploy", "appsignal:deploy"
+          after "deploy:migrations", "appsignal:deploy"
 
-        namespace :appsignal do
-          task :deploy do
-            env = fetch(:appsignal_env,
-              fetch(:stage, fetch(:rails_env, fetch(:rack_env, "production"))))
-            user = fetch(:appsignal_user, ENV["USER"] || ENV.fetch("USERNAME", nil))
-            revision = fetch(:appsignal_revision, fetch(:current_revision))
+          namespace :appsignal do
+            task :deploy do
+              env = fetch(:appsignal_env,
+                fetch(:stage, fetch(:rails_env, fetch(:rack_env, "production"))))
+              user = fetch(:appsignal_user, ENV["USER"] || ENV.fetch("USERNAME", nil))
+              revision = fetch(:appsignal_revision, fetch(:current_revision))
 
-            appsignal_config = Appsignal::Config.new(
-              ENV.fetch("PWD", nil),
-              env,
-              {},
-              Appsignal::Utils::IntegrationLogger.new(StringIO.new)
-            ).tap do |c|
-              fetch(:appsignal_config, {}).each do |key, value|
-                c[key] = value
+              appsignal_config = Appsignal::Config.new(
+                ENV.fetch("PWD", nil),
+                env,
+                {},
+                Appsignal::Utils::IntegrationLogger.new(StringIO.new)
+              ).tap do |c|
+                fetch(:appsignal_config, {}).each do |key, value|
+                  c[key] = value
+                end
+                c.validate
               end
-              c.validate
-            end
 
-            if appsignal_config&.active?
-              marker_data = {
-                :revision => revision,
-                :user => user
-              }
+              if appsignal_config&.active?
+                marker_data = {
+                  :revision => revision,
+                  :user => user
+                }
 
-              marker = Marker.new(marker_data, appsignal_config)
-              if config.dry_run
-                puts "Dry run: AppSignal deploy marker not actually sent."
+                marker = Marker.new(marker_data, appsignal_config)
+                if config.dry_run
+                  puts "Dry run: AppSignal deploy marker not actually sent."
+                else
+                  marker.transmit
+                end
               else
-                marker.transmit
+                puts "Not notifying of deploy, config is not active for environment: #{env}"
               end
-            else
-              puts "Not notifying of deploy, config is not active for environment: #{env}"
             end
           end
         end
@@ -51,5 +52,5 @@ module Appsignal
 end
 
 if ::Capistrano::Configuration.instance
-  Appsignal::Capistrano.tasks(::Capistrano::Configuration.instance)
+  Appsignal::Integrations::Capistrano.tasks(::Capistrano::Configuration.instance)
 end

data/lib/appsignal/integrations/data_mapper.rb

@@ -2,6 +2,7 @@
 
 module Appsignal
   class Hooks
+    # @api private
     module DataMapperLogListener
       SQL_CLASSES = [
         "DataObjects::SqlServer::Connection",

data/lib/appsignal/integrations/delayed_job_plugin.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Appsignal
-  class Hooks
+  module Integrations
     # @api private
     class DelayedJobPlugin < ::Delayed::Plugin
       extend Appsignal::Hooks::Helpers
@@ -17,52 +17,46 @@ module Appsignal
       end
 
       def self.invoke_with_instrumentation(job, block)
-        payload = job.payload_object
+        transaction =
+          Appsignal::Transaction.create(Appsignal::Transaction::BACKGROUND_JOB)
 
+        Appsignal.instrument("perform_job.delayed_job") do
+          block.call(job)
+        end
+      rescue Exception => error # rubocop:disable Lint/RescueException
+        transaction.set_error(error)
+        raise
+      ensure
+        payload = job.payload_object
         if payload.respond_to? :job_data
           # ActiveJob
           job_data = payload.job_data
-          args = job_data.fetch("arguments", {})
-          class_name = job_data["job_class"]
-          method_name = "perform"
+          transaction.set_action_if_nil("#{job_data["job_class"]}#perform")
+          transaction.set_params_if_nil(job_data.fetch("arguments", {}))
         else
           # Delayed Job
-          args = extract_value(payload, :args, {})
-          class_name, method_name = class_and_method_name_from_object_or_hash(payload, job.name)
+          transaction.set_action_if_nil(action_name_from_payload(payload, job.name))
+          transaction.set_params_if_nil(extract_value(payload, :args, {}))
         end
 
-        params = Appsignal::Utils::HashSanitizer.sanitize(
-          args,
-          Appsignal.config[:filter_parameters]
+        transaction.set_tags(
+          :id => extract_value(job, :id, nil, true),
+          :queue => extract_value(job, :queue),
+          :priority => extract_value(job, :priority, 0),
+          :attempts => extract_value(job, :attempts, 0)
         )
 
-        Appsignal.monitor_transaction(
-          "perform_job.delayed_job",
-          :class    => class_name,
-          :method   => method_name,
-          :metadata => {
-            :id => extract_value(job, :id, nil, true),
-            :queue => extract_value(job, :queue),
-            :priority => extract_value(job, :priority, 0),
-            :attempts => extract_value(job, :attempts, 0)
-          },
-          :params      => params,
-          :queue_start => extract_value(job, :run_at)
-        ) do
-          block.call(job)
-        end
+        transaction.set_queue_start(extract_value(job, :run_at)&.to_i&.* 1_000)
+
+        Appsignal::Transaction.complete_current!
       end
 
-      def self.class_and_method_name_from_object_or_hash(payload, default_name)
+      def self.action_name_from_payload(payload, default_name)
         # Attempt to find appsignal_name override
         class_and_method_name = extract_value(payload, :appsignal_name, nil)
-        return class_and_method_name.split("#") if class_and_method_name.is_a?(String)
-
-        pound_split = default_name.split("#")
-        return pound_split if pound_split.length == 2
-
-        dot_split = default_name.split(".")
-        return default_name if dot_split.length == 2
+        return class_and_method_name if class_and_method_name.is_a?(String)
+        return default_name if default_name.split("#").length == 2
+        return default_name if default_name.split(".").length == 2
 
         "#{default_name}#perform"
       end

data/lib/appsignal/integrations/dry_monitor.rb

@@ -2,6 +2,7 @@
 
 module Appsignal
   module Integrations
+    # @api private
     module DryMonitorIntegration
       def instrument(event_id, payload = {}, &block)
         Appsignal::Transaction.current.start_event

data/lib/appsignal/integrations/excon.rb

@@ -2,6 +2,7 @@
 
 module Appsignal
   module Integrations
+    # @api private
     module ExconIntegration
       def self.instrument(name, data, &block)
         namespace, *event = name.split(".")

data/lib/appsignal/integrations/grape.rb

@@ -3,6 +3,13 @@
 require "appsignal"
 require "appsignal/rack/grape_middleware"
 
+Appsignal::Utils::StdoutAndLoggerMessage.warning(
+  "The 'require \"appsignal/integrations/grape\"' file require integration " \
+    "method is deprecated. " \
+    "Please follow the Grape setup guide in our docs for the new method: " \
+    "https://docs.appsignal.com/ruby/integrations/grape.html"
+)
+
 Appsignal.internal_logger.debug("Loading Grape integration")
 
 module Appsignal

data/lib/appsignal/integrations/hanami.rb

@@ -1,48 +1,13 @@
 # frozen_string_literal: true
 
 require "appsignal"
-require "appsignal/rack/hanami_middleware"
 
-module Appsignal
-  module Integrations
-    # @api private
-    module HanamiPlugin
-      def self.init
-        Appsignal.internal_logger.debug("Loading Hanami integration")
+Appsignal::Utils::StdoutAndLoggerMessage.warning(
+  "The 'require \"appsignal/integrations/hanami\"' file require integration " \
+    "method is deprecated. " \
+    "Please follow the Hanami setup guide in our docs for the new method: " \
+    "https://docs.appsignal.com/ruby/integrations/hanami.html"
+)
 
-        hanami_app_config = ::Hanami.app.config
-
-        unless Appsignal.active?
-          Appsignal.config = Appsignal::Config.new(
-            hanami_app_config.root || Dir.pwd,
-            hanami_app_config.env
-          )
-          Appsignal.start
-        end
-
-        return unless Appsignal.active?
-
-        hanami_app_config.middleware.use(
-          ::Rack::Events,
-          [Appsignal::Rack::EventHandler.new]
-        )
-        hanami_app_config.middleware.use(Appsignal::Rack::HanamiMiddleware)
-
-        ::Hanami::Action.prepend Appsignal::Integrations::HanamiIntegration
-      end
-    end
-
-    # @api private
-    module HanamiIntegration
-      def call(env)
-        super
-      ensure
-        transaction = env[::Appsignal::Rack::APPSIGNAL_TRANSACTION]
-
-        transaction&.set_action_if_nil(self.class.name)
-      end
-    end
-  end
-end
-
-Appsignal::Integrations::HanamiPlugin.init unless Appsignal.testing?
+Appsignal.load(:hanami)
+Appsignal.start

data/lib/appsignal/integrations/http.rb

@@ -2,6 +2,7 @@
 
 module Appsignal
   module Integrations
+    # @api private
     module HttpIntegration
       def request(verb, uri, opts = {})
         parsed_request_uri = uri.is_a?(URI) ? uri : URI.parse(uri.to_s)

data/lib/appsignal/integrations/net_http.rb

@@ -2,6 +2,7 @@
 
 module Appsignal
   module Integrations
+    # @api private
     module NetHttpIntegration
       def request(request, body = nil, &block)
         Appsignal.instrument(

data/lib/appsignal/integrations/object.rb

@@ -3,6 +3,8 @@
 Appsignal::Environment.report_enabled("object_instrumentation") if defined?(Appsignal)
 
 class Object
+  # @see https://docs.appsignal.com/ruby/instrumentation/method-instrumentation.html
+  #   Method instrumentation documentation.
   def self.appsignal_instrument_class_method(method_name, options = {})
     singleton_class.send \
       :alias_method, "appsignal_uninstrumented_#{method_name}", method_name
@@ -20,6 +22,8 @@ class Object
     end
   end
 
+  # @see https://docs.appsignal.com/ruby/instrumentation/method-instrumentation.html
+  #   Method instrumentation documentation.
   def self.appsignal_instrument_method(method_name, options = {})
     alias_method "appsignal_uninstrumented_#{method_name}", method_name
     define_method method_name do |*args, &block|
@@ -33,12 +37,14 @@ class Object
     ruby2_keywords method_name if respond_to?(:ruby2_keywords, true)
   end
 
+  # @api private
   def self.appsignal_reverse_class_name
     return "AnonymousClass" unless name
 
     name.split("::").reverse.join(".")
   end
 
+  # @api private
   def appsignal_reverse_class_name
     self.class.appsignal_reverse_class_name
   end

data/lib/appsignal/integrations/padrino.rb

@@ -1,78 +1,13 @@
 # frozen_string_literal: true
 
 require "appsignal"
-require "appsignal/rack/sinatra_instrumentation"
 
-module Appsignal
-  module Integrations
-    # @api private
-    module PadrinoPlugin
-      def self.init
-        Padrino::Application.prepend Appsignal::Integrations::PadrinoIntegration
+Appsignal::Utils::StdoutAndLoggerMessage.warning(
+  "The 'require \"appsignal/integrations/padrino\"' file require integration " \
+    "method is deprecated. " \
+    "Please follow the Padrino setup guide in our docs for the new method: " \
+    "https://docs.appsignal.com/ruby/integrations/padrino.html"
+)
 
-        Padrino.before_load do
-          Appsignal.internal_logger.debug("Loading Padrino (#{Padrino::VERSION}) integration")
-
-          unless Appsignal.active?
-            root = Padrino.mounted_root
-            Appsignal.config = Appsignal::Config.new(root, Padrino.env)
-            Appsignal.start
-          end
-
-          next unless Appsignal.active?
-
-          Padrino.use ::Rack::Events, [Appsignal::Rack::EventHandler.new]
-          Padrino.use Appsignal::Rack::SinatraBaseInstrumentation,
-            :instrument_event_name => "process_action.padrino"
-        end
-      end
-    end
-  end
-end
-
-module Appsignal
-  module Integrations
-    # @api private
-    module PadrinoIntegration
-      def route!(base = settings, pass_block = nil)
-        return super if !Appsignal.active? || env["sinatra.static_file"]
-
-        begin
-          super
-        ensure
-          transaction = Appsignal::Transaction.current
-          transaction.set_action_if_nil(get_payload_action(request))
-        end
-      end
-
-      private
-
-      def get_payload_action(request)
-        # Short-circuit is there's no request object to obtain information from
-        return settings.name.to_s unless request
-
-        # Newer versions expose the action / controller on the request class.
-        # Newer versions also still expose a route_obj so we must prioritize the
-        # action/fullpath methods.
-        # The `request.action` and `request.controller` values are `nil` when a
-        # endpoint is not found, `""` if not specified by the user.
-        controller_name = request.controller if request.respond_to?(:controller)
-        action_name = request.action if request.respond_to?(:action)
-        action_name ||= ""
-
-        return "#{settings.name}:#{controller_name}##{action_name}" unless action_name.empty?
-
-        # Older versions of Padrino work with a route object
-        if request.respond_to?(:route_obj) && request.route_obj
-          return "#{settings.name}:#{request.route_obj.original_path}"
-        end
-
-        # Fall back to the application name if we haven't found an action name in
-        # any previous methods.
-        "#{settings.name}#unknown"
-      end
-    end
-  end
-end
-
-Appsignal::Integrations::PadrinoPlugin.init
+Appsignal.load(:padrino)
+Appsignal.start

data/lib/appsignal/integrations/que.rb

@@ -2,27 +2,11 @@
 
 module Appsignal
   module Integrations
+    # @api private
     module QuePlugin
       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)
-
-        transaction = Appsignal::Transaction.create(
-          SecureRandom.uuid,
-          Appsignal::Transaction::BACKGROUND_JOB,
-          request
-        )
+        transaction =
+          Appsignal::Transaction.create(Appsignal::Transaction::BACKGROUND_JOB)
 
         begin
           Appsignal.instrument("perform_job.que") { super }
@@ -30,7 +14,16 @@ module Appsignal
           transaction.set_error(error)
           raise error
         ensure
-          transaction.set_action_if_nil "#{local_attrs[:job_class]}#run"
+          local_attrs = respond_to?(:que_attrs) ? que_attrs : attrs
+          transaction.set_action_if_nil("#{local_attrs[:job_class]}#run")
+          transaction.set_params_if_nil(local_attrs[:args])
+          transaction.set_tags(
+            "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
+          )
           Appsignal::Transaction.complete_current!
         end
       end

data/lib/appsignal/integrations/railtie.rb

@@ -9,23 +9,49 @@ module Appsignal
   module Integrations
     # @api private
     class Railtie < ::Rails::Railtie
+      config.appsignal = ActiveSupport::OrderedOptions.new
+      config.appsignal.start_at = :on_load
+
+      # Run after the Rails framework is loaded
       initializer "appsignal.configure_rails_initialization" do |app|
-        Appsignal::Integrations::Railtie.initialize_appsignal(app)
+        Appsignal::Integrations::Railtie.on_load(app)
+      end
+
+      # Run after the Rails app's initializers are run
+      config.after_initialize do |app|
+        Appsignal::Integrations::Railtie.after_initialize(app)
       end
 
       console do
         Appsignal::Probes.stop
       end
 
-      def self.initialize_appsignal(app)
-        # Load config
-        Appsignal.config = Appsignal::Config.new(
-          Rails.root,
-          Rails.env,
-          :name => Appsignal::Utils::RailsHelper.detected_rails_app_name,
-          :log_path => Rails.root.join("log")
-        )
+      def self.on_load(app)
+        Appsignal::Integrations::Railtie.add_instrumentation_middleware(app)
+
+        return unless app.config.appsignal.start_at == :on_load
+
+        Appsignal::Integrations::Railtie.start
+      end
+
+      def self.after_initialize(app)
+        Appsignal::Integrations::Railtie.start if app.config.appsignal.start_at == :after_initialize
+      end
 
+      def self.start
+        unless Appsignal.config
+          Appsignal._config = Appsignal::Config.new(
+            Rails.root,
+            Rails.env,
+            :name => Appsignal::Utils::RailsHelper.detected_rails_app_name,
+            :log_path => Rails.root.join("log")
+          )
+        end
+        Appsignal.start
+        initialize_error_reporter
+      end
+
+      def self.add_instrumentation_middleware(app)
         app.middleware.insert(
           0,
           ::Rack::Events,
@@ -35,10 +61,6 @@ module Appsignal
           ActionDispatch::DebugExceptions,
           Appsignal::Rack::RailsInstrumentation
         )
-
-        Appsignal.start
-
-        initialize_error_reporter
       end
 
       def self.initialize_error_reporter
@@ -69,7 +91,7 @@ module Appsignal
             transaction.set_metadata("path", path)
             transaction.set_metadata("method", method)
             transaction.set_params_if_nil(params)
-            transaction.set_sample_data("custom_data", custom_data) if custom_data
+            transaction.set_custom_data(custom_data) if custom_data
 
             tags[:severity] = severity
             tags[:source] = source.to_s if source

data/lib/appsignal/integrations/rake.rb

@@ -33,11 +33,7 @@ module Appsignal
       private
 
       def _appsignal_create_transaction
-        Appsignal::Transaction.create(
-          SecureRandom.uuid,
-          Appsignal::Transaction::BACKGROUND_JOB,
-          Appsignal::Transaction::GenericRequest.new({})
-        )
+        Appsignal::Transaction.create(Appsignal::Transaction::BACKGROUND_JOB)
       end
     end
 

data/lib/appsignal/integrations/redis.rb

@@ -2,6 +2,7 @@
 
 module Appsignal
   module Integrations
+    # @api private
     module RedisIntegration
       def write(command)
         sanitized_command =

data/lib/appsignal/integrations/redis_client.rb

@@ -2,6 +2,7 @@
 
 module Appsignal
   module Integrations
+    # @api private
     module RedisClientIntegration
       def write(command)
         sanitized_command =

data/lib/appsignal/integrations/resque.rb

@@ -5,11 +5,7 @@ module Appsignal
     # @api private
     module ResqueIntegration
       def perform
-        transaction = Appsignal::Transaction.create(
-          SecureRandom.uuid,
-          Appsignal::Transaction::BACKGROUND_JOB,
-          Appsignal::Transaction::GenericRequest.new({})
-        )
+        transaction = Appsignal::Transaction.create(Appsignal::Transaction::BACKGROUND_JOB)
 
         Appsignal.instrument "perform.resque" do
           super
@@ -34,6 +30,7 @@ module Appsignal
       end
     end
 
+    # @api private
     class ResqueHelpers
       def self.arguments(payload)
         case payload["class"]