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

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,104 +23,6 @@ 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

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

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Appsignal
-  VERSION = "2.11.0.alpha.1".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/hooks/puma_spec.rb

@@ -55,7 +55,7 @@ describe Appsignal::Hooks::PumaHook do
 
             Appsignal::Hooks::PumaHook.new.install
             probe = Appsignal::Minutely.probes[:puma]
-            expect(probe).to eql(Appsignal::Hooks::PumaProbe)
+            expect(probe).to eql(Appsignal::Probes::PumaProbe)
           end
         end
       end
@@ -101,7 +101,7 @@ describe Appsignal::Hooks::PumaHook do
 
             Appsignal::Hooks::PumaHook.new.install
             probe = Appsignal::Minutely.probes[:puma]
-            expect(probe).to eql(Appsignal::Hooks::PumaProbe)
+            expect(probe).to eql(Appsignal::Probes::PumaProbe)
           end
         end
       end
@@ -116,182 +116,3 @@ describe Appsignal::Hooks::PumaHook do
     end
   end
 end
-
-describe Appsignal::Hooks::PumaProbe do
-  before(:context) do
-    Appsignal.config = project_fixture_config
-  end
-  after(:context) do
-    Appsignal.config = nil
-  end
-
-  let(:probe) { Appsignal::Hooks::PumaProbe.new }
-
-  describe "hostname" do
-    it "returns the socket hostname" do
-      expect(probe.send(:hostname)).to eql(Socket.gethostname)
-    end
-
-    context "with overridden hostname" do
-      around do |sample|
-        Appsignal.config[:hostname] = "frontend1"
-        sample.run
-        Appsignal.config[:hostname] = nil
-      end
-      it "returns the configured host" do
-        expect(probe.send(:hostname)).to eql("frontend1")
-      end
-    end
-  end
-
-  describe "#call" do
-    let(:expected_default_tags) { { :hostname => Socket.gethostname } }
-
-    context "with multiple worker stats" do
-      before(:context) do
-        class Puma
-          def self.stats
-            {
-              "workers" => 2,
-              "booted_workers" => 2,
-              "old_workers" => 0,
-              "worker_status" => [
-                {
-                  "last_status" => {
-                    "backlog" => 0,
-                    "running" => 5,
-                    "pool_capacity" => 5,
-                    "max_threads" => 5
-                  }
-                },
-                {
-                  "last_status" => {
-                    "backlog" => 0,
-                    "running" => 5,
-                    "pool_capacity" => 5,
-                    "max_threads" => 5
-                  }
-                }
-              ]
-            }.to_json
-          end
-        end
-      end
-      after(:context) { Object.send(:remove_const, :Puma) }
-
-      it "calls `puma_gauge` with the (summed) worker metrics" do
-        expect_gauge(:workers, 2, :type => :count)
-        expect_gauge(:workers, 2, :type => :booted)
-        expect_gauge(:workers, 0, :type => :old)
-
-        expect_gauge(:connection_backlog, 0)
-        expect_gauge(:pool_capacity, 10)
-        expect_gauge(:threads, 10, :type => :running)
-        expect_gauge(:threads, 10, :type => :max)
-
-        probe.call
-      end
-    end
-
-    context "with single worker stats" do
-      before(:context) do
-        class Puma
-          def self.stats
-            {
-              "backlog" => 0,
-              "running" => 5,
-              "pool_capacity" => 5,
-              "max_threads" => 5
-            }.to_json
-          end
-        end
-      end
-      after(:context) { Object.send(:remove_const, :Puma) }
-
-      it "calls `puma_gauge` with the (summed) worker metrics" do
-        expect_gauge(:connection_backlog, 0)
-        expect_gauge(:pool_capacity, 5)
-        expect_gauge(:threads, 5, :type => :running)
-        expect_gauge(:threads, 5, :type => :max)
-        probe.call
-      end
-    end
-
-    context "without stats" do
-      before(:context) do
-        class Puma
-          def self.stats
-          end
-        end
-      end
-      after(:context) { Object.send(:remove_const, :Puma) }
-
-      context "when it returns nil" do
-        it "does not track metrics" do
-          expect(probe).to_not receive(:puma_gauge)
-          probe.call
-        end
-      end
-
-      # Puma.stats raises a NoMethodError on a nil object on the first call.
-      context "when it returns a NoMethodError on the first call" do
-        let(:log) { StringIO.new }
-
-        it "ignores the first call and tracks the second call" do
-          use_logger_with log do
-            expect(Puma).to receive(:stats)
-              .and_raise(NoMethodError.new("undefined method `stats' for nil:NilClass"))
-            probe.call
-
-            expect(Puma).to receive(:stats).and_return({
-              "backlog" => 1,
-              "running" => 5,
-              "pool_capacity" => 4,
-              "max_threads" => 6
-            }.to_json)
-
-            expect_gauge(:connection_backlog, 1)
-            expect_gauge(:pool_capacity, 4)
-            expect_gauge(:threads, 5, :type => :running)
-            expect_gauge(:threads, 6, :type => :max)
-            probe.call
-          end
-
-          expect(log_contents(log)).to_not contains_log(:error, "Error in minutely probe 'puma'")
-        end
-      end
-
-      context "when it does not have a complete stats payload" do
-        let(:log) { StringIO.new }
-
-        it "tracks whatever metrics we do have" do
-          use_logger_with log do
-            expect(Puma).to receive(:stats).and_return({
-              "backlog" => 1,
-              "running" => 5
-            }.to_json)
-
-            expect_gauge(:connection_backlog, 1)
-            expect_no_gauge(:pool_capacity)
-            expect_gauge(:threads, 5, :type => :running)
-            expect_no_gauge(:threads, :type => :max)
-            probe.call
-          end
-
-          expect(log_contents(log)).to_not contains_log(:error, "Error in minutely probe 'puma'")
-        end
-      end
-    end
-
-    def expect_gauge(key, value, tags = {})
-      expect(Appsignal).to receive(:set_gauge)
-        .with("puma_#{key}", value, expected_default_tags.merge(tags))
-        .and_call_original
-    end
-
-    def expect_no_gauge(key, tags = {})
-      expect(Appsignal).to_not receive(:set_gauge)
-        .with("puma_#{key}", anything, tags)
-    end
-  end
-end