appsignal 2.11.0.alpha.1-java → 2.11.0.beta.4-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/que_spec.rb

@@ -14,7 +14,6 @@ if DependencyHelper.que_present?
           :error_count => 0
         }
       end
-
       let(:env) do
         {
           :class => "MyQueJob",
@@ -29,7 +28,6 @@ if DependencyHelper.que_present?
           :params => %w[1 birds]
         }
       end
-
       let(:job) do
         Class.new(::Que::Job) do
           def run(*args)
@@ -37,7 +35,6 @@ if DependencyHelper.que_present?
         end
       end
       let(:instance) { job.new(job_attrs) }
-
       before do
         allow(Que).to receive(:execute)
 
@@ -46,10 +43,14 @@ if DependencyHelper.que_present?
       end
       around { |example| keep_transactions { example.run } }
 
+      def perform_job(job)
+        job._run
+      end
+
       context "success" do
         it "creates a transaction for a job" do
           expect do
-            instance._run
+            perform_job(instance)
           end.to change { created_transactions.length }.by(1)
 
           expect(last_transaction).to be_completed
@@ -95,7 +96,7 @@ if DependencyHelper.que_present?
 
           expect do
             expect do
-              instance._run
+              perform_job(instance)
             end.to raise_error(ExampleException)
           end.to change { created_transactions.length }.by(1)
 
@@ -130,7 +131,7 @@ if DependencyHelper.que_present?
         it "reports errors and not re-raise them" do
           allow(instance).to receive(:run).and_raise(error)
 
-          expect { instance._run }.to change { created_transactions.length }.by(1)
+          expect { perform_job(instance) }.to change { created_transactions.length }.by(1)
 
           expect(last_transaction).to be_completed
           transaction_hash = last_transaction.to_h
@@ -156,6 +157,24 @@ if DependencyHelper.que_present?
           )
         end
       end
+
+      context "when action set in job" do
+        let(:job) do
+          Class.new(::Que::Job) do
+            def run(*_args)
+              Appsignal.set_action("MyCustomJob#perform")
+            end
+          end
+        end
+
+        it "uses the custom action" do
+          perform_job(instance)
+
+          expect(last_transaction).to be_completed
+          transaction_hash = last_transaction.to_h
+          expect(transaction_hash).to include("action" => "MyCustomJob#perform")
+        end
+      end
     end
   end
 end

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

@@ -1,187 +1,28 @@
-if DependencyHelper.active_job_present?
-  require "active_job"
-  require File.expand_path("lib/appsignal/integrations/resque_active_job.rb")
+require "appsignal/integrations/resque_active_job"
 
-  class TestActiveJob < ActiveJob::Base
-    include Appsignal::Integrations::ResqueActiveJobPlugin
+describe "Legacy Resque ActiveJob integration" do
+  let(:err_stream) { std_stream }
+  let(:stderr) { err_stream.read }
+  let(:log_stream) { std_stream }
+  let(:log) { log_contents(log_stream) }
 
-    def perform(_)
-    end
-  end
-
-  describe Appsignal::Integrations::ResqueActiveJobPlugin do
-    let(:args) { "argument" }
-    let(:job) { TestActiveJob.new(args) }
-    before { start_agent }
-
-    def perform
-      keep_transactions do
-        job.perform_now
-      end
-    end
-
-    context "without error" do
-      it "creates a new transaction" do
-        expect { perform }.to change { created_transactions.length }.by(1)
-
-        expect(last_transaction.to_h).to include(
-          "namespace" => Appsignal::Transaction::BACKGROUND_JOB,
-          "action" => "TestActiveJob#perform",
-          "error" => nil,
-          "events" => [
-            hash_including(
-              "name" => "perform_job.resque",
-              "title" => "",
-              "body" => "",
-              "body_format" => Appsignal::EventFormatter::DEFAULT,
-              "count" => 1,
-              "duration" => kind_of(Float)
-            )
-          ],
-          "sample_data" => hash_including(
-            "params" => ["argument"],
-            "metadata" => {
-              "id" => kind_of(String),
-              "queue" => "default"
-            }
-          )
-        )
-      end
-    end
-
-    context "with error" do
-      let(:job) do
-        class BrokenTestActiveJob < ActiveJob::Base
-          include Appsignal::Integrations::ResqueActiveJobPlugin
-
-          def perform(_)
-            raise ExampleException, "my error message"
-          end
-        end
-
-        BrokenTestActiveJob.new(args)
-      end
-
-      it "creates a new transaction with an error" do
-        expect do
-          expect { perform }.to raise_error(ExampleException, "my error message")
-        end.to change { created_transactions.length }.by(1)
+  it "logs and prints a deprecation message on extend" do
+    Appsignal.logger = test_logger(log_stream)
 
-        expect(last_transaction.to_h).to include(
-          "namespace" => Appsignal::Transaction::BACKGROUND_JOB,
-          "action" => "BrokenTestActiveJob#perform",
-          "error" => {
-            "name" => "ExampleException",
-            "message" => "my error message",
-            "backtrace" => kind_of(String)
-          },
-          "sample_data" => hash_including(
-            "params" => ["argument"],
-            "metadata" => {
-              "id" => kind_of(String),
-              "queue" => "default"
-            }
-          )
-        )
+    capture_std_streams(std_stream, err_stream) do
+      Class.new do
+        include Appsignal::Integrations::ResqueActiveJobPlugin
       end
     end
 
-    context "with complex arguments" do
-      context "with too long values" do
-        let(:args) do
-          {
-            :foo => "Foo",
-            :bar => "a" * 2001
-          }
-        end
-
-        it "truncates large argument values" do
-          perform
-          expect(last_transaction.to_h).to include(
-            "namespace" => Appsignal::Transaction::BACKGROUND_JOB,
-            "action" => "TestActiveJob#perform",
-            "error" => nil,
-            "sample_data" => hash_including(
-              "params" => ["foo" => "Foo", "bar" => "#{"a" * 2000}..."],
-              "metadata" => {
-                "id" => kind_of(String),
-                "queue" => "default"
-              }
-            )
-          )
-        end
-      end
-
-      context "with parameter filtering" do
-        let(:args) do
-          {
-            :foo => "Foo",
-            :bar => "Bar"
-          }
-        end
-        before { Appsignal.config[:filter_parameters] = ["foo"] }
-
-        it "filters selected arguments" do
-          perform
-          expect(last_transaction.to_h).to include(
-            "namespace" => Appsignal::Transaction::BACKGROUND_JOB,
-            "action" => "TestActiveJob#perform",
-            "error" => nil,
-            "sample_data" => hash_including(
-              "params" => ["foo" => "[FILTERED]", "bar" => "Bar"],
-              "metadata" => {
-                "id" => kind_of(String),
-                "queue" => "default"
-              }
-            )
-          )
-        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
+    deprecation_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" \
+      "#{__FILE__}:"
+    expect(stderr).to include "appsignal WARNING: #{deprecation_message}"
+    expect(log).to contains_log :warn, deprecation_message
   end
 end

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

@@ -1,93 +1,28 @@
-if DependencyHelper.resque_present?
-  describe "Resque integration" do
-    let(:file) { File.expand_path("lib/appsignal/integrations/resque.rb") }
+require "appsignal/integrations/resque"
 
-    context "with resque" do
-      before do
-        load file
-        start_agent
+describe "Legacy Resque integration" do
+  let(:err_stream) { std_stream }
+  let(:stderr) { err_stream.read }
+  let(:log_stream) { std_stream }
+  let(:log) { log_contents(log_stream) }
 
-        class TestJob
-          extend Appsignal::Integrations::ResquePlugin
+  it "logs and prints a deprecation message on extend" do
+    Appsignal.logger = test_logger(log_stream)
 
-          def self.perform
-          end
-        end
-
-        class BrokenTestJob
-          extend Appsignal::Integrations::ResquePlugin
-
-          def self.perform
-            raise ExampleException, "my error message"
-          end
-        end
-      end
-
-      describe :around_perform_resque_plugin do
-        let(:job) { ::Resque::Job.new("default", "class" => "TestJob") }
-        before { expect(Appsignal).to receive(:stop) }
-
-        context "without exception" do
-          it "creates a new transaction" do
-            expect do
-              keep_transactions { job.perform }
-            end.to change { created_transactions.length }.by(1)
-
-            expect(last_transaction).to be_completed
-            expect(last_transaction.to_h).to include(
-              "namespace" => Appsignal::Transaction::BACKGROUND_JOB,
-              "action" => "TestJob#perform",
-              "error" => nil,
-              "events" => [
-                hash_including(
-                  "name" => "perform_job.resque",
-                  "title" => "",
-                  "body" => "",
-                  "body_format" => Appsignal::EventFormatter::DEFAULT,
-                  "count" => 1,
-                  "duration" => kind_of(Float)
-                )
-              ]
-            )
-          end
-        end
-
-        context "with exception" do
-          let(:job) { ::Resque::Job.new("default", "class" => "BrokenTestJob") }
-
-          def perform
-            keep_transactions do
-              expect do
-                job.perform
-              end.to raise_error(ExampleException, "my error message")
-            end
-          end
-
-          it "sets the exception on the transaction" do
-            expect do
-              perform
-            end.to change { created_transactions.length }.by(1)
-
-            expect(last_transaction).to be_completed
-            expect(last_transaction.to_h).to include(
-              "namespace" => Appsignal::Transaction::BACKGROUND_JOB,
-              "action" => "BrokenTestJob#perform",
-              "error" => {
-                "name" => "ExampleException",
-                "message" => "my error message",
-                "backtrace" => kind_of(String)
-              }
-            )
-          end
-        end
+    capture_std_streams(std_stream, err_stream) do
+      Class.new do
+        extend Appsignal::Integrations::ResquePlugin
       end
     end
 
-    context "without resque" do
-      before(:context) { Object.send(:remove_const, :Resque) }
-
-      it { expect { ::Resque }.to raise_error(NameError) }
-      it { expect { load file }.to_not raise_error }
-    end
+    deprecation_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" \
+      "#{__FILE__}:"
+    expect(stderr).to include "appsignal WARNING: #{deprecation_message}"
+    expect(log).to contains_log :warn, deprecation_message
   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