appsignal 2.10.6 → 2.11.0

data/lib/appsignal/integrations/delayed_job_plugin.rb

@@ -27,9 +27,8 @@ module Appsignal
           method_name = "perform"
         else
           # Delayed Job
-          args = extract_value(job.payload_object, :args, {})
-          class_and_method_name = extract_value(job.payload_object, :appsignal_name, job.name)
-          class_name, method_name = class_and_method_name.split("#")
+          args = extract_value(payload, :args, {})
+          class_name, method_name = class_and_method_name_from_object_or_hash(payload, job.name)
         end
 
         params = Appsignal::Utils::HashSanitizer.sanitize(
@@ -54,6 +53,20 @@ module Appsignal
         end
       end
 
+      def self.class_and_method_name_from_object_or_hash(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
+
+        "#{default_name}#perform"
+      end
+
       def self.extract_value(object_or_hash, field, default_value = nil, convert_to_s = false)
         value = nil
 

data/lib/appsignal/integrations/object.rb

@@ -1,5 +1,9 @@
 # frozen_string_literal: true
 
+if defined?(Appsignal)
+  Appsignal::Environment.report_enabled("object_instrumentation")
+end
+
 class Object
   def self.appsignal_instrument_class_method(method_name, options = {})
     singleton_class.send \

data/lib/appsignal/integrations/que.rb

@@ -32,7 +32,7 @@ module Appsignal
               transaction.set_error(error)
               raise error
             ensure
-              transaction.set_action "#{local_attrs[:job_class]}#run"
+              transaction.set_action_if_nil "#{local_attrs[:job_class]}#run"
               Appsignal::Transaction.complete_current!
             end
           end

data/lib/appsignal/integrations/resque.rb

@@ -4,18 +4,15 @@ module Appsignal
   module Integrations
     # @api private
     module ResquePlugin
-      # Do not use this file as a template for your own background processor
-      # Resque is an exception to the rule and the code below causes the
-      # extension to shut itself down after a single job.
-      # see http://docs.appsignal.com/background-monitoring/custom.html
-      def around_perform_resque_plugin(*_args)
-        Appsignal.monitor_single_transaction(
-          "perform_job.resque",
-          :class => to_s,
-          :method => "perform"
-        ) do
-          yield
-        end
+      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}"
       end
     end
   end

data/lib/appsignal/integrations/resque_active_job.rb

@@ -4,30 +4,15 @@ module Appsignal
   module Integrations
     # @api private
     module ResqueActiveJobPlugin
-      include Appsignal::Hooks::Helpers
-
-      def self.included(base)
-        base.class_eval do
-          around_perform do |job, block|
-            params = Appsignal::Utils::HashSanitizer.sanitize(
-              job.arguments,
-              Appsignal.config[:filter_parameters]
-            )
-
-            Appsignal.monitor_single_transaction(
-              "perform_job.resque",
-              :class    => job.class.to_s,
-              :method   => "perform",
-              :params   => params,
-              :metadata => {
-                :id       => job.job_id,
-                :queue    => job.queue_name
-              }
-            ) do
-              block.call
-            end
-          end
-        end
+      def self.included(_)
+        callers = caller
+        Appsignal::Utils::DeprecationMessage.message \
+          "The AppSignal ResqueActiveJobPlugin 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: include Appsignal::Integrations::ResqueActiveJobPlugin\n" \
+          "#{callers.first}"
       end
     end
   end

data/lib/appsignal/probes.rb

@@ -0,0 +1,7 @@
+module Appsignal
+  module Probes
+  end
+end
+
+require "appsignal/probes/puma"
+require "appsignal/probes/sidekiq"

data/lib/appsignal/probes/puma.rb

@@ -0,0 +1,61 @@
+module Appsignal
+  module Probes
+    class PumaProbe
+      def initialize
+        @hostname = Appsignal.config[:hostname] || Socket.gethostname
+      end
+
+      # @api private
+      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/probes/sidekiq.rb

@@ -0,0 +1,104 @@
+module Appsignal
+  module Probes
+    class SidekiqProbe
+      # @api private
+      attr_reader :config
+
+      # @api private
+      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
+
+      # @api private
+      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
+  end
+end

data/lib/appsignal/rack/js_exception_catcher.rb

@@ -29,8 +29,11 @@ module Appsignal
         Appsignal.logger.debug \
           "Initializing Appsignal::Rack::JSExceptionCatcher"
         deprecation_message "The Appsignal::Rack::JSExceptionCatcher is " \
-          "deprecated. Please use the official AppSignal JavaScript " \
-          "integration instead. https://docs.appsignal.com/front-end/"
+          "deprecated and will be removed in a future version. Please use " \
+          "the official AppSignal JavaScript integration by disabling " \
+          "`enable_frontend_error_catching` in your configuration and " \
+          "installing AppSignal for JavaScript instead. " \
+          "(https://docs.appsignal.com/front-end/)"
         @app = app
       end
 

data/lib/appsignal/system.rb

@@ -76,14 +76,8 @@ module Appsignal
       ldd_version && ldd_version[0]
     end
 
-    # @api private
     def self.jruby?
       RUBY_PLATFORM == "java"
     end
-
-    # @api private
-    def self.ruby_2_or_up?
-      versionify(RUBY_VERSION) >= versionify("2.0")
-    end
   end
 end

data/lib/appsignal/transaction.rb

@@ -221,6 +221,16 @@ module Appsignal
       set_action_if_nil(group_and_action.compact.join("#"))
     end
 
+    # Set queue start time for transaction.
+    #
+    # Most commononly called by {set_http_or_background_queue_start}.
+    #
+    # @param start [Integer] Queue start time in milliseconds.
+    # @raise [RangeError] When the queue start time value is too big, this
+    #   method raises a RangeError.
+    # @raise [TypeError] Raises a TypeError when the given `start` argument is
+    #   not an Integer.
+    # @return [void]
     def set_queue_start(start)
       return unless start
       @ext.set_queue_start(start)
@@ -228,12 +238,27 @@ module Appsignal
       Appsignal.logger.warn("Queue start value #{start} is too big")
     end
 
+    # Set the queue time based on the HTTP header or `:queue_start` env key
+    # value.
+    #
+    # This method will first try to read the queue time from the HTTP headers
+    # `X-Request-Start` or `X-Queue-Start`. Which are parsed by Rack as
+    # `HTTP_X_QUEUE_START` and `HTTP_X_REQUEST_START`.
+    # The header value is parsed by AppSignal as either milliseconds or
+    # microseconds.
+    #
+    # If no headers are found, or the value could not be parsed, it falls back
+    # on the `:queue_start` env key on this Transaction's {request} environment
+    # (called like `request.env[:queue_start]`). This value is parsed by
+    # AppSignal as seconds.
+    #
+    # @see https://docs.appsignal.com/ruby/instrumentation/request-queue-time.html
+    # @return [void]
     def set_http_or_background_queue_start
-      if namespace == HTTP_REQUEST
-        set_queue_start(http_queue_start)
-      elsif namespace == BACKGROUND_JOB
-        set_queue_start(background_queue_start)
-      end
+      start = http_queue_start || background_queue_start
+      return unless start
+
+      set_queue_start(start)
     end
 
     def set_metadata(key, value)
@@ -346,14 +371,14 @@ module Appsignal
     #
     # @return [nil] if no {#environment} is present.
     # @return [nil] if there is no `:queue_start` in the {#environment}.
-    # @return [Integer]
+    # @return [Integer] `:queue_start` time (in seconds) converted to milliseconds
     def background_queue_start
       env = environment
       return unless env
       queue_start = env[:queue_start]
       return unless queue_start
 
-      (queue_start.to_f * 1000.0).to_i
+      (queue_start.to_f * 1000.0).to_i # Convert seconds to milliseconds
     end
 
     # Returns HTTP queue start time in milliseconds.

data/lib/appsignal/utils/deprecation_message.rb

@@ -1,10 +1,14 @@
 module Appsignal
   module Utils
     module DeprecationMessage
-      def deprecation_message(message, logger = Appsignal.logger)
-        $stderr.puts "appsignal WARNING: #{message}"
+      def self.message(message, logger = Appsignal.logger)
+        Kernel.warn "appsignal WARNING: #{message}"
         logger.warn message
       end
+
+      def deprecation_message(message, logger = Appsignal.logger)
+        Appsignal::Utils::DeprecationMessage.message(message, logger)
+      end
     end
   end
 end

data/lib/appsignal/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Appsignal
-  VERSION = "2.10.6".freeze
+  VERSION = "2.11.0".freeze
 end

data/lib/puma/plugin/appsignal.rb

@@ -17,7 +17,8 @@ Puma::Plugin.create do
     launcher.events.on_booted do
       require "appsignal"
       if ::Puma.respond_to?(:stats)
-        Appsignal::Minutely.probes.register :puma, Appsignal::Hooks::PumaProbe
+        require "appsignal/probes/puma"
+        Appsignal::Minutely.probes.register :puma, Appsignal::Probes::PumaProbe
       end
       Appsignal.start
       Appsignal.start_logger

data/spec/lib/appsignal/auth_check_spec.rb

@@ -28,6 +28,29 @@ describe Appsignal::AuthCheck do
     end.join("&")
   end
 
+  describe ".new" do
+    describe "with logger argument" do
+      let(:err_stream) { std_stream }
+      let(:stderr) { err_stream.read }
+      let(:log_stream) { std_stream }
+      let(:log) { log_contents(log_stream) }
+
+      it "logs and prints a deprecation message" do
+        Appsignal.logger = test_logger(log_stream)
+
+        capture_std_streams(std_stream, err_stream) do
+          Appsignal::AuthCheck.new(config, Appsignal.logger)
+        end
+
+        deprecation_message =
+          "`Appsignal::AuthCheck.new`'s `logger` argument " \
+          "will be removed in the next major version."
+        expect(stderr).to include "appsignal WARNING: #{deprecation_message}"
+        expect(log).to contains_log :warn, deprecation_message
+      end
+    end
+  end
+
   describe "#perform" do
     subject { auth_check.perform }