appsignal 2.10.7-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/integrations/resque_active_job_spec.rb

@@ -1,21 +1,18 @@
-if DependencyHelper.resque_present? && DependencyHelper.active_job_present?
+if DependencyHelper.active_job_present?
   require "active_job"
+  require File.expand_path("lib/appsignal/integrations/resque_active_job.rb")
+
+  class TestActiveJob < ActiveJob::Base
+    include Appsignal::Integrations::ResqueActiveJobPlugin
+
+    def perform(_)
+    end
+  end
 
   describe Appsignal::Integrations::ResqueActiveJobPlugin do
-    let(:file) { File.expand_path("lib/appsignal/integrations/resque_active_job.rb") }
     let(:args) { "argument" }
     let(:job) { TestActiveJob.new(args) }
-    before do
-      load file
-      start_agent
-
-      class TestActiveJob < ActiveJob::Base
-        include Appsignal::Integrations::ResqueActiveJobPlugin
-
-        def perform(_)
-        end
-      end
-    end
+    before { start_agent }
 
     def perform
       keep_transactions do
@@ -141,5 +138,50 @@ if DependencyHelper.resque_present? && DependencyHelper.active_job_present?
         end
       end
     end
+
+    context "without queue time" do
+      it "does not add queue time to transaction" do
+        # TODO: Not available in transaction.to_h yet.
+        # https://github.com/appsignal/appsignal-agent/issues/293
+        expect(Appsignal).to receive(:monitor_single_transaction).with(
+          "perform_job.resque",
+          a_hash_including(:queue_start => nil)
+        ).and_call_original
+
+        perform
+        expect(last_transaction.to_h).to include(
+          "namespace" => Appsignal::Transaction::BACKGROUND_JOB,
+          "action" => "TestActiveJob#perform",
+          "events" => [
+            hash_including("name" => "perform_job.resque")
+          ]
+        )
+      end
+    end
+
+    if DependencyHelper.rails6_present?
+      context "with queue time" do
+        it "adds queue time to transction" do
+          queue_start = "2017-01-01 10:01:00UTC"
+          queue_start_time = Time.parse(queue_start)
+          # TODO: Not available in transaction.to_h yet.
+          # https://github.com/appsignal/appsignal-agent/issues/293
+          expect(Appsignal).to receive(:monitor_single_transaction).with(
+            "perform_job.resque",
+            a_hash_including(:queue_start => queue_start_time)
+          ).and_call_original
+          job.enqueued_at = queue_start
+
+          perform
+          expect(last_transaction.to_h).to include(
+            "namespace" => Appsignal::Transaction::BACKGROUND_JOB,
+            "action" => "TestActiveJob#perform",
+            "events" => [
+              hash_including("name" => "perform_job.resque")
+            ]
+          )
+        end
+      end
+    end
   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