appsignal 2.10.7-java → 2.11.0.alpha.2-java

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
+
+        ["unknown"]
+      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/resque_active_job.rb

@@ -14,12 +14,18 @@ module Appsignal
               Appsignal.config[:filter_parameters]
             )
 
+            queue_start =
+              if job.respond_to?(:enqueued_at) && job.enqueued_at
+                Time.parse(job.enqueued_at).utc
+              end
+
             Appsignal.monitor_single_transaction(
               "perform_job.resque",
-              :class    => job.class.to_s,
-              :method   => "perform",
-              :params   => params,
-              :metadata => {
+              :class       => job.class.to_s,
+              :method      => "perform",
+              :params      => params,
+              :queue_start => queue_start,
+              :metadata    => {
                 :id       => job.job_id,
                 :queue    => job.queue_name
               }
@@ -28,6 +34,8 @@ module Appsignal
             end
           end
         end
+
+        Appsignal::Environment.report("ruby_active_job_resque_enabled") { true }
       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

@@ -228,12 +228,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 +361,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/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Appsignal
-  VERSION = "2.10.7".freeze
+  VERSION = "2.11.0.alpha.2".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