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

data/spec/lib/appsignal/integrations/padrino_spec.rb

@@ -142,7 +142,7 @@ if DependencyHelper.padrino_present?
               expect_a_transaction_to_be_created
               # Uses path for action name
               expect(transaction).to receive(:set_action_if_nil).with("PadrinoTestApp#unknown")
-              expect(response).to match_response(404, "<h1>Not Found</h1>")
+              expect(response).to match_response(404, "GET /404")
             end
           end
 

data/spec/lib/appsignal/probes/puma_spec.rb

@@ -0,0 +1,180 @@
+require "appsignal/probes/puma"
+
+describe Appsignal::Probes::PumaProbe do
+  before(:context) do
+    Appsignal.config = project_fixture_config
+  end
+  after(:context) do
+    Appsignal.config = nil
+  end
+
+  let(:probe) { described_class.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

data/spec/lib/appsignal/probes/sidekiq_spec.rb

@@ -0,0 +1,201 @@
+require "appsignal/probes/sidekiq"
+
+describe Appsignal::Probes::SidekiqProbe do
+  describe "#call" do
+    let(:probe) { described_class.new }
+    let(:redis_hostname) { "localhost" }
+    let(:expected_default_tags) { { :hostname => "localhost" } }
+    before do
+      Appsignal.config = project_fixture_config
+      module Sidekiq
+        def self.redis_info
+          {
+            "connected_clients" => 2,
+            "used_memory" => 1024,
+            "used_memory_rss" => 512
+          }
+        end
+
+        def self.redis
+          yield Client.new
+        end
+
+        class Client
+          def connection
+            { :host => "localhost" }
+          end
+        end
+
+        class Stats
+          class << self
+            attr_reader :calls
+
+            def count_call
+              @calls ||= -1
+              @calls += 1
+            end
+          end
+
+          def workers_size
+            # First method called, so count it towards a call
+            self.class.count_call
+            24
+          end
+
+          def processes_size
+            25
+          end
+
+          # Return two different values for two separate calls.
+          # This allows us to test the delta of the value send as a gauge.
+          def processed
+            [10, 15][self.class.calls]
+          end
+
+          # Return two different values for two separate calls.
+          # This allows us to test the delta of the value send as a gauge.
+          def failed
+            [10, 13][self.class.calls]
+          end
+
+          def retry_size
+            12
+          end
+
+          # Return two different values for two separate calls.
+          # This allows us to test the delta of the value send as a gauge.
+          def dead_size
+            [10, 12][self.class.calls]
+          end
+
+          def scheduled_size
+            14
+          end
+
+          def enqueued
+            15
+          end
+        end
+
+        class Queue
+          Queue = Struct.new(:name, :size, :latency)
+
+          def self.all
+            [
+              Queue.new("default", 10, 12),
+              Queue.new("critical", 1, 2)
+            ]
+          end
+        end
+      end
+    end
+    after { Object.send(:remove_const, "Sidekiq") }
+
+    describe ".dependencies_present?" do
+      before do
+        class Redis; end
+        Redis.const_set(:VERSION, version)
+      end
+      after { Object.send(:remove_const, "Redis") }
+
+      context "when Redis version is < 3.3.5" do
+        let(:version) { "3.3.4" }
+
+        it "does not start probe" do
+          expect(described_class.dependencies_present?).to be_falsy
+        end
+      end
+
+      context "when Redis version is >= 3.3.5" do
+        let(:version) { "3.3.5" }
+
+        it "does not start probe" do
+          expect(described_class.dependencies_present?).to be_truthy
+        end
+      end
+    end
+
+    it "loads Sidekiq::API" do
+      expect(defined?(Sidekiq::API)).to be_falsy
+      probe
+      expect(defined?(Sidekiq::API)).to be_truthy
+    end
+
+    it "logs config on initialize" do
+      log = capture_logs { probe }
+      expect(log).to contains_log(:debug, "Initializing Sidekiq probe\n")
+    end
+
+    it "logs used hostname on call once" do
+      log = capture_logs { probe.call }
+      expect(log).to contains_log(
+        :debug,
+        %(Sidekiq probe: Using Redis server hostname "localhost" as hostname)
+      )
+      log = capture_logs { probe.call }
+      # Match more logs with incompelete message
+      expect(log).to_not contains_log(:debug, %(Sidekiq probe: ))
+    end
+
+    it "collects custom metrics" do
+      expect_gauge("worker_count", 24).twice
+      expect_gauge("process_count", 25).twice
+      expect_gauge("connection_count", 2).twice
+      expect_gauge("memory_usage", 1024).twice
+      expect_gauge("memory_usage_rss", 512).twice
+      expect_gauge("job_count", 5, :status => :processed) # Gauge delta
+      expect_gauge("job_count", 3, :status => :failed) # Gauge delta
+      expect_gauge("job_count", 12, :status => :retry_queue).twice
+      expect_gauge("job_count", 2, :status => :died) # Gauge delta
+      expect_gauge("job_count", 14, :status => :scheduled).twice
+      expect_gauge("job_count", 15, :status => :enqueued).twice
+      expect_gauge("queue_length", 10, :queue => "default").twice
+      expect_gauge("queue_latency", 12_000, :queue => "default").twice
+      expect_gauge("queue_length", 1, :queue => "critical").twice
+      expect_gauge("queue_latency", 2_000, :queue => "critical").twice
+      # Call probe twice so we can calculate the delta for some gauge values
+      probe.call
+      probe.call
+    end
+
+    context "when `redis_info` is not defined" do
+      before do
+        allow(Sidekiq).to receive(:respond_to?).with(:redis_info).and_return(false)
+      end
+
+      it "does not collect redis metrics" do
+        expect_gauge("connection_count", 2).never
+        expect_gauge("memory_usage", 1024).never
+        expect_gauge("memory_usage_rss", 512).never
+        probe.call
+      end
+    end
+
+    context "when hostname is configured for probe" do
+      let(:redis_hostname) { "my_redis_server" }
+      let(:probe) { described_class.new(:hostname => redis_hostname) }
+
+      it "uses the redis hostname for the hostname tag" do
+        allow(Appsignal).to receive(:set_gauge).and_call_original
+        log = capture_logs { probe }
+        expect(log).to contains_log(
+          :debug,
+          %(Initializing Sidekiq probe with config: {:hostname=>"#{redis_hostname}"})
+        )
+        log = capture_logs { probe.call }
+        expect(log).to contains_log(
+          :debug,
+          "Sidekiq probe: Using hostname config option #{redis_hostname.inspect} as hostname"
+        )
+        expect(Appsignal).to have_received(:set_gauge)
+          .with(anything, anything, :hostname => redis_hostname).at_least(:once)
+      end
+    end
+
+    def expect_gauge(key, value, tags = {})
+      expect(Appsignal).to receive(:set_gauge)
+        .with("sidekiq_#{key}", value, expected_default_tags.merge(tags))
+        .and_call_original
+    end
+  end
+end

data/spec/lib/appsignal/rack/js_exception_catcher_spec.rb

@@ -4,9 +4,12 @@ describe Appsignal::Rack::JSExceptionCatcher do
   let(:config_options) { { :enable_frontend_error_catching => true } }
   let(:config)         { project_fixture_config("production", config_options) }
   let(:deprecation_message) do
-    "The Appsignal::Rack::JSExceptionCatcher is deprecated. " \
-      "Please use the official AppSignal JavaScript integration instead. " \
-      "https://docs.appsignal.com/front-end/"
+    "The Appsignal::Rack::JSExceptionCatcher is " \
+      "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/)"
   end
   before { Appsignal.config = config }
 
@@ -32,7 +35,9 @@ describe Appsignal::Rack::JSExceptionCatcher do
 
   describe "#call" do
     let(:catcher) do
-      silence { Appsignal::Rack::JSExceptionCatcher.new(app, options) }
+      silence :allowed => ["enable_frontend_error_catching"] do
+        Appsignal::Rack::JSExceptionCatcher.new(app, options)
+      end
     end
     after { catcher.call(env) }
 

data/spec/lib/puma/appsignal_spec.rb

@@ -62,7 +62,7 @@ RSpec.describe "Puma plugin" do
     expect(launcher.events.on_booted).to_not be_nil
 
     launcher.events.on_booted.call
-    expect(Appsignal::Minutely.probes[:puma]).to eql(Appsignal::Hooks::PumaProbe)
+    expect(Appsignal::Minutely.probes[:puma]).to eql(Appsignal::Probes::PumaProbe)
 
     # Minutely probes started and called
     wait_for("enough probe calls") { probe.calls >= 2 }

data/spec/support/stubs/sidekiq/api.rb

@@ -1,4 +1,4 @@
-class Sidekiq
+module Sidekiq
   class API
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: appsignal
 version: !ruby/object:Gem::Version
-  version: 2.11.0.alpha.1
+  version: 2.11.0.alpha.2
 platform: java
 authors:
 - Robert Beekman
@@ -10,7 +10,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-06-29 00:00:00.000000000 Z
+date: 2020-07-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rack
@@ -255,6 +255,8 @@ files:
 - lib/appsignal/logger.rb
 - lib/appsignal/marker.rb
 - lib/appsignal/minutely.rb
+- lib/appsignal/probes/puma.rb
+- lib/appsignal/probes/sidekiq.rb
 - lib/appsignal/rack/generic_instrumentation.rb
 - lib/appsignal/rack/js_exception_catcher.rb
 - lib/appsignal/rack/rails_instrumentation.rb
@@ -334,6 +336,8 @@ files:
 - spec/lib/appsignal/logger_spec.rb
 - spec/lib/appsignal/marker_spec.rb
 - spec/lib/appsignal/minutely_spec.rb
+- spec/lib/appsignal/probes/puma_spec.rb
+- spec/lib/appsignal/probes/sidekiq_spec.rb
 - spec/lib/appsignal/rack/generic_instrumentation_spec.rb
 - spec/lib/appsignal/rack/js_exception_catcher_spec.rb
 - spec/lib/appsignal/rack/rails_instrumentation_spec.rb
@@ -476,6 +480,8 @@ test_files:
 - spec/lib/appsignal/logger_spec.rb
 - spec/lib/appsignal/marker_spec.rb
 - spec/lib/appsignal/minutely_spec.rb
+- spec/lib/appsignal/probes/puma_spec.rb
+- spec/lib/appsignal/probes/sidekiq_spec.rb
 - spec/lib/appsignal/rack/generic_instrumentation_spec.rb
 - spec/lib/appsignal/rack/js_exception_catcher_spec.rb
 - spec/lib/appsignal/rack/rails_instrumentation_spec.rb