appsignal 2.10.9.beta.1-java → 2.11.0.beta.2-java

data/lib/appsignal/hooks/active_job.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module Appsignal
+  class Hooks
+    # @api private
+    class ActiveJobHook < Appsignal::Hooks::Hook
+      register :active_job
+
+      def dependencies_present?
+        defined?(::ActiveJob)
+      end
+
+      def install
+        ::ActiveJob::Base
+          .extend ::Appsignal::Hooks::ActiveJobHook::ActiveJobClassInstrumentation
+      end
+
+      # @todo Add queue time support for Rails 6's enqueued_at. For both
+      #   existing and new transactions.
+      module ActiveJobClassInstrumentation
+        def execute(job)
+          current_transaction = Appsignal::Transaction.current
+          transaction =
+            if current_transaction.nil_transaction?
+              # No standalone integration started before ActiveJob integration.
+              # We don't have a separate integration for this QueueAdapter like
+              # 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({})
+              )
+            else
+              current_transaction
+            end
+
+          super
+        rescue Exception => exception # rubocop:disable Lint/RescueException
+          transaction.set_error(exception)
+          raise exception
+        ensure
+          if transaction
+            transaction.params =
+              Appsignal::Utils::HashSanitizer.sanitize(
+                job["arguments"],
+                Appsignal.config[:filter_parameters]
+              )
+
+            tags = { :queue => job["queue_name"] }
+            provider_job_id = job["provider_job_id"]
+            tags[:provider_job_id] = provider_job_id if provider_job_id
+            transaction.set_tags(tags)
+
+            transaction.set_action_if_nil(ActiveJobHelpers.action_name(job))
+            enqueued_at = job["enqueued_at"]
+            if enqueued_at # Present in Rails 6 and up
+              transaction.set_queue_start((Time.parse(enqueued_at).to_f * 1_000).to_i)
+            end
+
+            if current_transaction.nil_transaction?
+              # Only complete transaction if ActiveJob is not wrapped in
+              # another supported integration, such as Sidekiq.
+              Appsignal::Transaction.complete_current!
+            end
+          end
+        end
+      end
+
+      module ActiveJobHelpers
+        ACTION_MAILER_CLASSES = [
+          "ActionMailer::DeliveryJob",
+          "ActionMailer::Parameterized::DeliveryJob",
+          "ActionMailer::MailDeliveryJob"
+        ].freeze
+
+        def self.action_name(job)
+          case job["job_class"]
+          when *ACTION_MAILER_CLASSES
+            job["arguments"][0..1].join("#")
+          else
+            "#{job["job_class"]}#perform"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/appsignal/hooks/net_http.rb

@@ -25,6 +25,8 @@ module Appsignal
             end
           end
         end
+
+        Appsignal::Environment.report_enabled("net_http")
       end
     end
   end

data/lib/appsignal/hooks/puma.rb

@@ -24,7 +24,8 @@ module Appsignal
           # runs in the Puma main process.
           # For more information:
           # https://docs.appsignal.com/ruby/integrations/puma.html
-          Appsignal::Minutely.probes.register :puma, PumaProbe
+          require "appsignal/probes/puma"
+          Appsignal::Minutely.probes.register :puma, ::Appsignal::Probes::PumaProbe
         end
 
         return unless defined?(::Puma::Cluster)
@@ -39,62 +40,5 @@ module Appsignal
         end
       end
     end
-
-    class PumaProbe
-      def initialize
-        @hostname = Appsignal.config[:hostname] || Socket.gethostname
-      end
-
-      def call
-        puma_stats = fetch_puma_stats
-        return unless puma_stats
-
-        stats = JSON.parse puma_stats, :symbolize_names => true
-        counts = {}
-        count_keys = [:backlog, :running, :pool_capacity, :max_threads]
-
-        if stats[:worker_status] # Multiple workers
-          stats[:worker_status].each do |worker|
-            stat = worker[:last_status]
-            count_keys.each do |key|
-              count_if_present counts, key, stat
-            end
-          end
-
-          gauge(:workers, stats[:workers], :type => :count)
-          gauge(:workers, stats[:booted_workers], :type => :booted)
-          gauge(:workers, stats[:old_workers], :type => :old)
-        else # Single worker
-          count_keys.each do |key|
-            count_if_present counts, key, stats
-          end
-        end
-
-        gauge(:connection_backlog, counts[:backlog]) if counts[:backlog]
-        gauge(:pool_capacity, counts[:pool_capacity]) if counts[:pool_capacity]
-        gauge(:threads, counts[:running], :type => :running) if counts[:running]
-        gauge(:threads, counts[:max_threads], :type => :max) if counts[:max_threads]
-      end
-
-      private
-
-      attr_reader :hostname
-
-      def gauge(field, count, tags = {})
-        Appsignal.set_gauge("puma_#{field}", count, tags.merge(:hostname => hostname))
-      end
-
-      def count_if_present(counts, key, stats)
-        stat_value = stats[key]
-        return unless stat_value
-        counts[key] ||= 0
-        counts[key] += stat_value
-      end
-
-      def fetch_puma_stats
-        ::Puma.stats
-      rescue NoMethodError # rubocop:disable Lint/HandleExceptions
-      end
-    end
   end
 end

data/lib/appsignal/hooks/redis.rb

@@ -26,6 +26,8 @@ module Appsignal
             end
           end
         end
+
+        Appsignal::Environment.report_enabled("redis")
       end
     end
   end

data/lib/appsignal/hooks/resque.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module Appsignal
+  class Hooks
+    # @api private
+    class ResqueHook < Appsignal::Hooks::Hook
+      register :resque
+
+      def dependencies_present?
+        defined?(::Resque)
+      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
+      end
+    end
+  end
+end

data/lib/appsignal/hooks/sequel.rb

@@ -56,6 +56,8 @@ module Appsignal
 
         # ... and automatically add it to future instances.
         ::Sequel::Database.extension(:appsignal_integration)
+
+        Appsignal::Environment.report_enabled("sequel")
       end
     end
   end

data/lib/appsignal/hooks/sidekiq.rb

@@ -12,7 +12,8 @@ module Appsignal
       end
 
       def install
-        Appsignal::Minutely.probes.register :sidekiq, SidekiqProbe
+        require "appsignal/probes/sidekiq"
+        Appsignal::Minutely.probes.register :sidekiq, Appsignal::Probes::SidekiqProbe
 
         ::Sidekiq.configure_server do |config|
           config.server_middleware do |chain|
@@ -22,110 +23,11 @@ module Appsignal
       end
     end
 
-    class SidekiqProbe
-      attr_reader :config
-
-      def self.dependencies_present?
-        Gem::Version.new(::Redis::VERSION) >= Gem::Version.new("3.3.5")
-      end
-
-      def initialize(config = {})
-        @config = config
-        @cache = {}
-        config_string = " with config: #{config}" unless config.empty?
-        Appsignal.logger.debug("Initializing Sidekiq probe#{config_string}")
-        require "sidekiq/api"
-      end
-
-      def call
-        track_redis_info
-        track_stats
-        track_queues
-      end
-
-      private
-
-      attr_reader :cache
-
-      def track_redis_info
-        return unless ::Sidekiq.respond_to?(:redis_info)
-        redis_info = ::Sidekiq.redis_info
-
-        gauge "connection_count", redis_info.fetch("connected_clients")
-        gauge "memory_usage", redis_info.fetch("used_memory")
-        gauge "memory_usage_rss", redis_info.fetch("used_memory_rss")
-      end
-
-      def track_stats
-        stats = ::Sidekiq::Stats.new
-
-        gauge "worker_count", stats.workers_size
-        gauge "process_count", stats.processes_size
-        gauge_delta :jobs_processed, "job_count", stats.processed,
-          :status => :processed
-        gauge_delta :jobs_failed, "job_count", stats.failed, :status => :failed
-        gauge "job_count", stats.retry_size, :status => :retry_queue
-        gauge_delta :jobs_dead, "job_count", stats.dead_size, :status => :died
-        gauge "job_count", stats.scheduled_size, :status => :scheduled
-        gauge "job_count", stats.enqueued, :status => :enqueued
-      end
-
-      def track_queues
-        ::Sidekiq::Queue.all.each do |queue|
-          gauge "queue_length", queue.size, :queue => queue.name
-          # Convert latency from seconds to milliseconds
-          gauge "queue_latency", queue.latency * 1_000.0, :queue => queue.name
-        end
-      end
-
-      # Track a gauge metric with the `sidekiq_` prefix
-      def gauge(key, value, tags = {})
-        tags[:hostname] = hostname if hostname
-        Appsignal.set_gauge "sidekiq_#{key}", value, tags
-      end
-
-      # Track the delta of two values for a gauge metric
-      #
-      # First call will store the data for the metric and the second call will
-      # set a gauge metric with the difference. This is used for absolute
-      # counter values which we want to track as gauges.
-      #
-      # @example
-      #   gauge_delta :my_cache_key, "my_gauge", 10
-      #   gauge_delta :my_cache_key, "my_gauge", 15
-      #   # Creates a gauge with the value `5`
-      # @see #gauge
-      def gauge_delta(cache_key, key, value, tags = {})
-        previous_value = cache[cache_key]
-        cache[cache_key] = value
-        return unless previous_value
-        new_value = value - previous_value
-        gauge key, new_value, tags
-      end
-
-      def hostname
-        return @hostname if defined?(@hostname)
-        if config.key?(:hostname)
-          @hostname = config[:hostname]
-          Appsignal.logger.debug "Sidekiq probe: Using hostname config " \
-            "option #{@hostname.inspect} as hostname"
-          return @hostname
-        end
-
-        host = nil
-        ::Sidekiq.redis { |c| host = c.connection[:host] }
-        Appsignal.logger.debug "Sidekiq probe: Using Redis server hostname " \
-          "#{host.inspect} as hostname"
-        @hostname = host
-      end
-    end
-
     # @api private
     class SidekiqPlugin # rubocop:disable Metrics/ClassLength
       include Appsignal::Hooks::Helpers
 
-      UNKNOWN_ACTION_NAME = "unknown".freeze
-      JOB_KEYS = %w[
+      EXCLUDED_JOB_KEYS = %w[
         args backtrace class created_at enqueued_at error_backtrace error_class
         error_message failed_at jid retried_at retry wrapped
       ].freeze
@@ -152,7 +54,10 @@ module Appsignal
       ensure
         if transaction
           transaction.set_action_if_nil(formatted_action_name(item))
-          transaction.params = filtered_arguments(item)
+
+          params = filtered_arguments(item)
+          transaction.params = params if params
+
           formatted_metadata(item).each do |key, value|
             transaction.set_metadata key, value
           end
@@ -178,16 +83,20 @@ module Appsignal
 
       def formatted_action_name(job)
         sidekiq_action_name = parse_action_name(job)
+        return unless sidekiq_action_name
+
         complete_action = sidekiq_action_name =~ /\.|#/
-        if complete_action || sidekiq_action_name == UNKNOWN_ACTION_NAME
-          return sidekiq_action_name
-        end
+        return sidekiq_action_name if complete_action
+
         "#{sidekiq_action_name}#perform"
       end
 
       def filtered_arguments(job)
+        arguments = parse_arguments(job)
+        return unless arguments
+
         Appsignal::Utils::HashSanitizer.sanitize(
-          parse_arguments(job),
+          arguments,
           Appsignal.config[:filter_parameters]
         )
       end
@@ -195,7 +104,8 @@ module Appsignal
       def formatted_metadata(item)
         {}.tap do |hash|
           (item || {}).each do |key, value|
-            next if JOB_KEYS.include?(key)
+            next if EXCLUDED_JOB_KEYS.include?(key)
+
             hash[key] = truncate(string_or_inspect(value))
           end
         end
@@ -214,81 +124,11 @@ module Appsignal
           safe_load(args[0], job_class) do |target, method, _|
             "#{target}.#{method}"
           end
-        when "ActiveJob::QueueAdapters::SidekiqAdapter::JobWrapper"
-          wrapped_job = job["wrapped"]
-          if wrapped_job
-            parse_active_job_action_name_from_wrapped job
-          else
-            parse_active_job_action_name_from_arguments job
-          end
         else
           job_class
         end
       end
 
-      # Return the ActiveJob wrapped job name.
-      #
-      # Returns "unknown" if no acceptable job class name could be found.
-      #
-      # @example Payload with "wrapped" value
-      #   {
-      #     "class" => "ActiveJob::QueueAdapters::SidekiqAdapter::JobWrapper",
-      #     "wrapped" => "MyWrappedJob",
-      #     # ...
-      #   }
-      def parse_active_job_action_name_from_wrapped(job)
-        job_class = job["wrapped"]
-        case job_class
-        when "ActionMailer::DeliveryJob"
-          extract_action_mailer_name job["args"]
-        when String
-          job_class
-        else
-          unknown_action_name_for job
-        end
-      end
-
-      # Return the ActiveJob job name based on the job's arguments.
-      #
-      # Returns "unknown" if no acceptable job class name could be found.
-      #
-      # @example Payload without "wrapped" value
-      #   {
-      #     "class" => "ActiveJob::QueueAdapters::SidekiqAdapter::JobWrapper",
-      #     "args" => [{
-      #       "job_class" => "MyWrappedJob",
-      #       # ...
-      #     }]
-      #     # ...
-      #   }
-      def parse_active_job_action_name_from_arguments(job)
-        args = job.fetch("args", [])
-        first_arg = args[0]
-        if first_arg == "ActionMailer::DeliveryJob"
-          extract_action_mailer_name args
-        elsif active_job_payload?(first_arg)
-          first_arg["job_class"]
-        else
-          unknown_action_name_for job
-        end
-      end
-
-      # Checks if the first argument in the job payload is an ActiveJob payload.
-      def active_job_payload?(arg)
-        arg.is_a?(Hash) && arg["job_class"].is_a?(String)
-      end
-
-      def unknown_action_name_for(job)
-        Appsignal.logger.debug \
-          "Unable to determine an action name from Sidekiq payload: #{job}"
-        UNKNOWN_ACTION_NAME
-      end
-
-      def extract_action_mailer_name(args)
-        # Returns in format: MailerClass#mailer_method
-        args[0]["arguments"][0..1].join("#")
-      end
-
       # Based on: https://github.com/mperham/sidekiq/blob/63ee43353bd3b753beb0233f64865e658abeb1c3/lib/sidekiq/api.rb#L336-L358
       def parse_arguments(job)
         args = job.fetch("args", [])
@@ -298,20 +138,7 @@ module Appsignal
             arg
           end
         when "ActiveJob::QueueAdapters::SidekiqAdapter::JobWrapper"
-          is_wrapped = job["wrapped"]
-          first_arg = args[0]
-          job_args =
-            if is_wrapped || active_job_payload?(first_arg)
-              first_arg["arguments"]
-            else
-              []
-            end
-          if (is_wrapped || first_arg) == "ActionMailer::DeliveryJob"
-            # Remove MailerClass, mailer_method and "deliver_now"
-            job_args.drop(3)
-          else
-            job_args
-          end
+          nil # Set in the ActiveJob integration
         else
           # Sidekiq Enterprise argument encryption.
           # More information: https://github.com/mperham/sidekiq/wiki/Ent-Encryption