appsignal 2.10.8-java → 2.11.0.beta.1-java

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/puma.rb

@@ -0,0 +1,61 @@
+module Appsignal
+  module Probes
+    # @api private
+    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/probes/sidekiq.rb

@@ -0,0 +1,102 @@
+module Appsignal
+  module Probes
+    # @api private
+    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
+  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/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)
+      def self.message(message, logger = Appsignal.logger)
         $stderr.puts "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.8".freeze
+  VERSION = "2.11.0.beta.1".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/cli/diagnose_spec.rb

@@ -263,7 +263,8 @@ describe Appsignal::CLI::Diagnose, :api_stub => true, :send_report => :yes_cli_i
           },
           "download" => {
             "download_url" => kind_of(String),
-            "checksum" => "verified"
+            "checksum" => "verified",
+            "http_proxy" => nil
           },
           "build" => {
             "time" => kind_of(String),

data/spec/lib/appsignal/config_spec.rb

@@ -148,6 +148,7 @@ describe Appsignal::Config do
         :instrument_redis               => true,
         :instrument_sequel              => true,
         :skip_session_data              => false,
+        :send_environment_metadata      => true,
         :send_params                    => true,
         :endpoint                       => "https://push.appsignal.com",
         :push_api_key                   => "abc",
@@ -411,7 +412,8 @@ describe Appsignal::Config do
         :instrument_sequel => false,
         :files_world_accessible => false,
         :request_headers => %w[accept accept-charset],
-        :revision => "v2.5.1"
+        :revision => "v2.5.1",
+        :send_environment_metadata => false
       }
     end
     before do
@@ -428,6 +430,7 @@ describe Appsignal::Config do
       ENV["APPSIGNAL_INSTRUMENT_SEQUEL"]       = "false"
       ENV["APPSIGNAL_FILES_WORLD_ACCESSIBLE"]  = "false"
       ENV["APPSIGNAL_REQUEST_HEADERS"]         = "accept,accept-charset"
+      ENV["APPSIGNAL_SEND_ENVIRONMENT_METADATA"] = "false"
       ENV["APP_REVISION"] = "v2.5.1"
     end
 
@@ -527,6 +530,7 @@ describe Appsignal::Config do
       config[:running_in_container] = false
       config[:dns_servers] = ["8.8.8.8", "8.8.4.4"]
       config[:transaction_debug_mode] = true
+      config[:send_environment_metadata] = false
       config[:revision] = "v2.5.1"
       config.write_to_environment
     end
@@ -555,6 +559,7 @@ describe Appsignal::Config do
       expect(ENV["_APPSIGNAL_DNS_SERVERS"]).to                  eq "8.8.8.8,8.8.4.4"
       expect(ENV["_APPSIGNAL_FILES_WORLD_ACCESSIBLE"]).to       eq "true"
       expect(ENV["_APPSIGNAL_TRANSACTION_DEBUG_MODE"]).to       eq "true"
+      expect(ENV["_APPSIGNAL_SEND_ENVIRONMENT_METADATA"]).to    eq "false"
       expect(ENV["_APP_REVISION"]).to                           eq "v2.5.1"
       expect(ENV).to_not                                        have_key("_APPSIGNAL_WORKING_DIR_PATH")
       expect(ENV).to_not                                        have_key("_APPSIGNAL_WORKING_DIRECTORY_PATH")

data/spec/lib/appsignal/environment_spec.rb

@@ -0,0 +1,167 @@
+describe Appsignal::Environment do
+  include EnvironmentMetadataHelper
+
+  before(:context) { start_agent }
+  before { capture_environment_metadata_report_calls }
+
+  def report(key, &value_block)
+    described_class.report(key, &value_block)
+  end
+
+  describe ".report" do
+    it "sends environment metadata to the extension" do
+      logs =
+        capture_logs do
+          report("_test_ruby_version") { "1.0.0" }
+          expect_environment_metadata("_test_ruby_version", "1.0.0")
+        end
+      expect(logs).to be_empty
+    end
+
+    context "when the key is a non String type" do
+      it "does not set the value" do
+        logs =
+          capture_logs do
+            report(:_test_symbol) { "1.0.0" }
+            expect_not_environment_metadata(:_test_symbol)
+            expect_not_environment_metadata("_test_symbol")
+          end
+        expect(logs).to contains_log(
+          :error,
+          "Unable to report on environment metadata: Unsupported value type for :_test_symbol"
+        )
+      end
+    end
+
+    context "when the key is nil" do
+      it "does not set the value" do
+        logs =
+          capture_logs do
+            report(nil) { "1" }
+            expect_not_environment_metadata(nil)
+          end
+        expect(logs).to contains_log(
+          :error,
+          "Unable to report on environment metadata: Unsupported value type for nil"
+        )
+      end
+    end
+
+    context "when the value is true or false" do
+      it "reports true or false as Strings" do
+        logs =
+          capture_logs do
+            report("_test_true") { true }
+            report("_test_false") { false }
+            expect_environment_metadata("_test_true", "true")
+            expect_environment_metadata("_test_false", "false")
+          end
+        expect(logs).to be_empty
+      end
+    end
+
+    context "when the value is nil" do
+      it "does not set the value" do
+        logs =
+          capture_logs do
+            report("_test_ruby_version") { nil }
+            expect_not_environment_metadata("_test_ruby_version")
+          end
+        expect(logs).to contains_log(
+          :error,
+          "Unable to report on environment metadata \"_test_ruby_version\": " \
+            "Unsupported value type for nil"
+        )
+      end
+    end
+
+    context "when the value block raises an error" do
+      it "does not re-raise the error and writes it to the log" do
+        logs =
+          capture_logs do
+            report("_test_error") { raise "uh oh" }
+            expect_not_environment_metadata("_test_error")
+          end
+        expect(logs).to contains_log(
+          :error,
+          "Unable to report on environment metadata \"_test_error\":\n" \
+            "RuntimeError: uh oh"
+        )
+      end
+    end
+
+    context "when something unforseen errors" do
+      it "does not re-raise the error and writes it to the log" do
+        klass = Class.new do
+          def inspect
+            raise "inspect error"
+          end
+        end
+
+        logs =
+          capture_logs do
+            report(klass.new) { raise "value error" }
+            expect(Appsignal::Extension).to_not have_received(:set_environment_metadata)
+          end
+        expect(logs).to contains_log(
+          :error,
+          "Unable to report on environment metadata:\n" \
+            "RuntimeError: inspect error"
+        )
+      end
+    end
+  end
+
+  describe ".report_supported_gems" do
+    it "reports about all AppSignal supported gems in the bundle" do
+      logs = capture_logs { described_class.report_supported_gems }
+
+      expect(logs).to be_empty
+
+      bundle_gem_specs = ::Bundler.rubygems.all_specs
+      rack_spec = bundle_gem_specs.find { |s| s.name == "rack" }
+      rake_spec = bundle_gem_specs.find { |s| s.name == "rake" }
+      expect_environment_metadata("ruby_rack_version", rack_spec.version.to_s)
+      expect_environment_metadata("ruby_rake_version", rake_spec.version.to_s)
+      expect(rack_spec.version.to_s).to_not be_empty
+      expect(rake_spec.version.to_s).to_not be_empty
+    end
+
+    context "when something unforseen errors" do
+      it "does not re-raise the error and writes it to the log" do
+        expect(Bundler).to receive(:rubygems).and_raise(RuntimeError, "bundler error")
+
+        logs = capture_logs { described_class.report_supported_gems }
+        expect(logs).to contains_log(
+          :error,
+          "Unable to report supported gems:\nRuntimeError: bundler error"
+        )
+      end
+    end
+  end
+
+  describe ".report_enabled" do
+    it "reports a feature being enabled" do
+      logs = capture_logs { described_class.report_enabled("a_test") }
+
+      expect(logs).to be_empty
+      expect_environment_metadata("ruby_a_test_enabled", "true")
+    end
+
+    context "when something unforseen errors" do
+      it "does not re-raise the error and writes it to the log" do
+        klass = Class.new do
+          def to_s
+            raise "to_s error"
+          end
+        end
+
+        logs = capture_logs { described_class.report_enabled(klass.new) }
+        expect(logs).to contains_log(
+          :error,
+          "Unable to report integration enabled:\nRuntimeError: to_s error"
+        )
+      end
+    end
+  end
+end