appsignal 3.9.3-java → 3.11.0-java

data/lib/appsignal/hooks/active_job.rb

@@ -54,25 +54,13 @@ module Appsignal
               # we do for Sidekiq.
               #
               # Prefer job_id from provider, instead of ActiveJob's internal ID.
-              Appsignal::Transaction.create(
-                job["provider_job_id"] || job["job_id"],
-                Appsignal::Transaction::BACKGROUND_JOB,
-                Appsignal::Transaction::GenericRequest.new({})
-              )
+              Appsignal::Transaction.create(Appsignal::Transaction::BACKGROUND_JOB)
             end
 
           if transaction
-            transaction.set_params_if_nil(
-              Appsignal::Utils::HashSanitizer.sanitize(
-                job["arguments"],
-                Appsignal.config[:filter_parameters]
-              )
-            )
+            transaction.set_params_if_nil(job["arguments"])
 
             transaction_tags = ActiveJobHelpers.transaction_tags_for(job)
-            transaction_tags["active_job_id"] = job["job_id"]
-            provider_job_id = job["provider_job_id"]
-            transaction_tags[:provider_job_id] = provider_job_id if provider_job_id
             transaction.set_tags(transaction_tags)
 
             transaction.set_action(ActiveJobHelpers.action_name(job))
@@ -159,12 +147,25 @@ module Appsignal
 
         def self.transaction_tags_for(job)
           tags = {}
+
           queue = job["queue_name"]
           tags[:queue] = queue if queue
+
           priority = job["priority"]
           tags[:priority] = priority if priority
+
           executions = job["executions"]
           tags[:executions] = executions.to_i + 1 if executions
+
+          job_id = job["job_id"]
+          tags[:active_job_id] = job_id
+
+          provider_job_id = job["provider_job_id"]
+          tags[:provider_job_id] = provider_job_id if provider_job_id
+
+          request_id = provider_job_id || job_id
+          tags[:request_id] = request_id if request_id
+
           tags
         end
 

data/lib/appsignal/hooks/delayed_job.rb

@@ -14,7 +14,7 @@ module Appsignal
         # The DJ plugin is a subclass of Delayed::Plugin, so we can only
         # require this code if we're actually installing.
         require "appsignal/integrations/delayed_job_plugin"
-        ::Delayed::Worker.plugins << Appsignal::Hooks::DelayedJobPlugin
+        ::Delayed::Worker.plugins << Appsignal::Integrations::DelayedJobPlugin
       end
     end
   end

data/lib/appsignal/hooks/shoryuken.rb

@@ -3,68 +3,6 @@
 module Appsignal
   class Hooks
     # @api private
-    class ShoryukenMiddleware
-      def call(worker_instance, queue, sqs_msg, body, &block)
-        batch = sqs_msg.is_a?(Array)
-        attributes =
-          if batch
-            # We can't instrument batched message separately, the `yield` will
-            # perform all the batched messages.
-            # To provide somewhat useful metadata, Get first message based on
-            # SentTimestamp, and use its attributes as metadata for the
-            # transaction. We can't combine them all because then they would
-            # overwrite each other and the last message (in an sorted order)
-            # would be used as the source of the metadata.  With the
-            # oldest/first message at least some useful information is stored
-            # such as the first received time and the number of retries for the
-            # first message. The newer message should have lower values and
-            # timestamps in their metadata.
-            first_msg = sqs_msg.min do |a, b|
-              a.attributes["SentTimestamp"].to_i <=> b.attributes["SentTimestamp"].to_i
-            end
-            # Add batch => true metadata so people can recognize when a
-            # transaction is about a batch of messages.
-            first_msg.attributes.merge(:batch => true)
-          else
-            sqs_msg.attributes.merge(:message_id => sqs_msg.message_id)
-          end
-        metadata = { :queue => queue }.merge(attributes)
-        options = {
-          :class => worker_instance.class.name,
-          :method => "perform",
-          :metadata => metadata
-        }
-
-        args =
-          if batch
-            bodies = {}
-            sqs_msg.each_with_index do |msg, index|
-              # Store all separate bodies on a hash with the key being the
-              # message_id
-              bodies[msg.message_id] = body[index]
-            end
-            bodies
-          else
-            case body
-            when Hash
-              body
-            else
-              { :params => body }
-            end
-          end
-        options[:params] = Appsignal::Utils::HashSanitizer.sanitize(
-          args,
-          Appsignal.config[:filter_parameters]
-        )
-
-        if attributes.key?("SentTimestamp")
-          options[:queue_start] = Time.at(attributes["SentTimestamp"].to_i / 1000)
-        end
-
-        Appsignal.monitor_transaction("perform_job.shoryuken", options, &block)
-      end
-    end
-
     class ShoryukenHook < Appsignal::Hooks::Hook
       register :shoryuken
 
@@ -73,9 +11,11 @@ module Appsignal
       end
 
       def install
+        require "appsignal/integrations/shoryuken"
+
         ::Shoryuken.configure_server do |config|
           config.server_middleware do |chain|
-            chain.add Appsignal::Hooks::ShoryukenMiddleware
+            chain.add Appsignal::Integrations::ShoryukenMiddleware
           end
         end
       end

data/lib/appsignal/integrations/action_cable.rb

@@ -2,19 +2,16 @@
 
 module Appsignal
   module Integrations
+    # @api private
     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
+        request_id = request.request_id || SecureRandom.uuid
+        env[Appsignal::Hooks::ActionCableHook::REQUEST_ID] ||= request_id
 
-        transaction = Appsignal::Transaction.create(
-          env[Appsignal::Hooks::ActionCableHook::REQUEST_ID],
-          Appsignal::Transaction::ACTION_CABLE,
-          request
-        )
+        transaction = Appsignal::Transaction.create(Appsignal::Transaction::ACTION_CABLE)
 
         begin
           super
@@ -26,6 +23,7 @@ module Appsignal
           transaction.set_action_if_nil("#{self.class}##{args.first["action"]}")
           transaction.set_metadata("path", request.path)
           transaction.set_metadata("method", "websocket")
+          transaction.set_tags(:request_id => request_id) if request_id
           Appsignal::Transaction.complete_current!
         end
       end

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/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,18 +1,30 @@
 # frozen_string_literal: true
 
 require "appsignal"
+require "appsignal/rack/sinatra_instrumentation"
 
 module Appsignal
   module Integrations
     # @api private
     module PadrinoPlugin
       def self.init
-        Appsignal.internal_logger.debug("Loading Padrino (#{Padrino::VERSION}) integration")
+        Padrino::Application.prepend Appsignal::Integrations::PadrinoIntegration
 
-        root = Padrino.mounted_root
-        Appsignal.config = Appsignal::Config.new(root, Padrino.env)
+        Padrino.before_load do
+          Appsignal.internal_logger.debug("Loading Padrino (#{Padrino::VERSION}) integration")
 
-        Appsignal.start
+          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
@@ -20,35 +32,23 @@ 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"]
 
-        transaction = Appsignal::Transaction.create(
-          SecureRandom.uuid,
-          Appsignal::Transaction::HTTP_REQUEST,
-          request
-        )
         begin
-          Appsignal.instrument("process_action.padrino") do
-            super
-          end
-        rescue Exception => error # rubocop:disable Lint/RescueException
-          transaction.set_error(error)
-          raise error
+          super
         ensure
+          transaction = Appsignal::Transaction.current
           transaction.set_action_if_nil(get_payload_action(request))
-          transaction.set_metadata("path", request.path)
-          transaction.set_metadata("method", request.request_method)
-          transaction.set_http_or_background_queue_start
-          Appsignal::Transaction.complete_current!
         end
       end
 
       private
 
       def get_payload_action(request)
-        # Short-circut is there's no request object to obtain information from
+        # 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.
@@ -75,8 +75,4 @@ module Appsignal
   end
 end
 
-Padrino::Application.prepend Appsignal::Integrations::PadrinoIntegration
-
-Padrino.after_load do
-  Appsignal::Integrations::PadrinoPlugin.init
-end
+Appsignal::Integrations::PadrinoPlugin.init

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

@@ -69,7 +69,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

@@ -2,26 +2,56 @@
 
 module Appsignal
   module Integrations
+    # @api private
     module RakeIntegration
       def execute(*args)
-        super
+        transaction =
+          if Appsignal.config[:enable_rake_performance_instrumentation]
+            Appsignal::Integrations::RakeIntegrationHelper.register_at_exit_hook
+            _appsignal_create_transaction
+          end
+
+        Appsignal.instrument "task.rake" do
+          super
+        end
       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)
+        Appsignal::Integrations::RakeIntegrationHelper.register_at_exit_hook
+        transaction ||= _appsignal_create_transaction
         transaction.set_error(error)
-        transaction.complete
-        Appsignal.stop("rake")
         raise error
+      ensure
+        if transaction
+          # Format given arguments and cast to hash if possible
+          params, _ = args
+          params = params.to_hash if params.respond_to?(:to_hash)
+          transaction.set_params_if_nil(params)
+          transaction.set_action(name)
+          transaction.complete
+        end
+      end
+
+      private
+
+      def _appsignal_create_transaction
+        Appsignal::Transaction.create(Appsignal::Transaction::BACKGROUND_JOB)
+      end
+    end
+
+    # @api private
+    module RakeIntegrationHelper
+      # Register an `at_exit` hook when a task is executed. This will stop
+      # AppSignal when _all_ tasks are executed and Rake exits.
+      def self.register_at_exit_hook
+        return if @register_at_exit_hook
+
+        Kernel.at_exit(&method(:at_exit_hook))
+
+        @register_at_exit_hook = true
+      end
+
+      # The at_exit hook itself
+      def self.at_exit_hook
+        Appsignal.stop("rake")
       end
     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 =