appsignal 3.9.2 → 3.9.3

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

@@ -4,6 +4,13 @@ describe Appsignal::Probes::GvlProbe do
 
   let(:hostname) { "some-host" }
 
+  around do |example|
+    real_program_name = $PROGRAM_NAME
+    example.run
+  ensure
+    $PROGRAM_NAME = real_program_name
+  end
+
   def gauges_for(metric)
     gauges = appsignal_mock.gauges.select do |gauge|
       gauge[0] == metric
@@ -14,7 +21,7 @@ describe Appsignal::Probes::GvlProbe do
     end
   end
 
-  after(:each) { FakeGVLTools.reset }
+  after { FakeGVLTools.reset }
 
   it "gauges the global timer delta" do
     FakeGVLTools::GlobalTimer.monotonic_time = 100_000_000
@@ -26,6 +33,11 @@ describe Appsignal::Probes::GvlProbe do
     probe.call
 
     expect(gauges_for("gvl_global_timer")).to eq [
+      [200, {
+        :hostname => hostname,
+        :process_name => "rspec",
+        :process_id => Process.pid
+      }],
       [200, { :hostname => hostname }]
     ]
   end
@@ -58,7 +70,7 @@ describe Appsignal::Probes::GvlProbe do
   end
 
   context "when the waiting threads count is enabled" do
-    before(:each) do
+    before do
       FakeGVLTools::WaitingThreads.enabled = true
     end
 
@@ -67,13 +79,18 @@ describe Appsignal::Probes::GvlProbe do
       probe.call
 
       expect(gauges_for("gvl_waiting_threads")).to eq [
+        [3, {
+          :hostname => hostname,
+          :process_name => "rspec",
+          :process_id => Process.pid
+        }],
         [3, { :hostname => hostname }]
       ]
     end
   end
 
   context "when the waiting threads count is disabled" do
-    before(:each) do
+    before do
       FakeGVLTools::WaitingThreads.enabled = false
     end
 
@@ -84,4 +101,64 @@ describe Appsignal::Probes::GvlProbe do
       expect(gauges_for("gvl_waiting_threads")).to be_empty
     end
   end
+
+  context "when the process name is a custom value" do
+    before do
+      FakeGVLTools::WaitingThreads.enabled = true
+    end
+
+    it "uses only the first word as the process name" do
+      $PROGRAM_NAME = "sidekiq 7.1.6 app [0 of 5 busy]"
+      probe.call
+
+      expect(gauges_for("gvl_waiting_threads")).to eq [
+        [0, {
+          :hostname => hostname,
+          :process_name => "sidekiq",
+          :process_id => Process.pid
+        }],
+        [0, { :hostname => hostname }]
+      ]
+    end
+  end
+
+  context "when the process name is a path" do
+    before do
+      FakeGVLTools::WaitingThreads.enabled = true
+    end
+
+    it "uses only the binary name as the process name" do
+      $PROGRAM_NAME = "/foo/folder with spaces/bin/rails"
+      probe.call
+
+      expect(gauges_for("gvl_waiting_threads")).to eq [
+        [0, {
+          :hostname => hostname,
+          :process_name => "rails",
+          :process_id => Process.pid
+        }],
+        [0, { :hostname => hostname }]
+      ]
+    end
+  end
+
+  context "when the process name is an empty string" do
+    before do
+      FakeGVLTools::WaitingThreads.enabled = true
+    end
+
+    it "uses [unknown process] as the process name" do
+      $PROGRAM_NAME = ""
+      probe.call
+
+      expect(gauges_for("gvl_waiting_threads")).to eq [
+        [0, {
+          :hostname => hostname,
+          :process_name => "[unknown process]",
+          :process_id => Process.pid
+        }],
+        [0, { :hostname => hostname }]
+      ]
+    end
+  end
 end

data/spec/lib/appsignal/probes_spec.rb

@@ -20,7 +20,7 @@ describe Appsignal::Probes do
         .to include("appsignal WARNING: The constant Appsignal::Minutely has been deprecated.")
     end
 
-    it "logs a warning to STDERR" do
+    it "logs a warning" do
       logs =
         capture_logs do
           silence do
@@ -28,7 +28,10 @@ describe Appsignal::Probes do
           end
         end
 
-      expect(logs).to include("The constant Appsignal::Minutely has been deprecated.")
+      expect(logs).to contains_log(
+        :warn,
+        "The constant Appsignal::Minutely has been deprecated."
+      )
     end
   end
 
@@ -78,7 +81,7 @@ describe Appsignal::Probes do
     describe ".started?" do
       it "returns true when the probes thread has been started" do
         expect(Appsignal::Probes.started?).to be_falsy
-        Appsignal::Probes.register :my_probe, (lambda {})
+        Appsignal::Probes.register :my_probe, lambda {}
         Appsignal::Probes.start
         expect(Appsignal::Probes.started?).to be_truthy
       end
@@ -475,7 +478,7 @@ describe Appsignal::Probes do
         probe = lambda {}
         collection.internal_register :my_probe, probe
         list = []
-        collection.each do |name, p|
+        collection.each do |name, p| # rubocop:disable Style/MapIntoArray
           list << [name, p]
         end
         expect(list).to eql([[:my_probe, probe]])

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

@@ -1,5 +1,5 @@
 describe Appsignal::Rack::AbstractMiddleware do
-  let(:app) { double(:call => true) }
+  let(:app) { DummyApp.new }
   let(:request_path) { "/some/path" }
   let(:env) do
     Rack::MockRequest.env_for(
@@ -9,176 +9,235 @@ describe Appsignal::Rack::AbstractMiddleware do
     )
   end
   let(:options) { {} }
-  let(:middleware) { Appsignal::Rack::AbstractMiddleware.new(app, options) }
+  let(:middleware) { described_class.new(app, options) }
 
   before(:context) { start_agent }
   around { |example| keep_transactions { example.run } }
 
-  def make_request(env)
+  def make_request
     middleware.call(env)
   end
 
-  def make_request_with_error(env, error)
-    expect { make_request(env) }.to raise_error(error)
+  def make_request_with_error(error_class, error_message)
+    expect { make_request }.to raise_error(error_class, error_message)
   end
 
   describe "#call" do
-    context "when appsignal is not active" do
+    context "when not active" do
       before { allow(Appsignal).to receive(:active?).and_return(false) }
 
-      it "does not instrument requests" do
-        expect { make_request(env) }.to_not(change { created_transactions.count })
+      it "does not instrument the request" do
+        expect { make_request }.to_not(change { created_transactions.count })
       end
 
       it "calls the next middleware in the stack" do
-        expect(app).to receive(:call).with(env)
-        make_request(env)
+        make_request
+        expect(app).to be_called
       end
     end
 
     context "when appsignal is active" do
       before { allow(Appsignal).to receive(:active?).and_return(true) }
 
-      it "calls the next middleware in the stack" do
-        make_request(env)
+      it "creates a transaction for the request" do
+        expect { make_request }.to(change { created_transactions.count }.by(1))
 
-        expect(app).to have_received(:call).with(env)
+        expect(last_transaction).to have_namespace(Appsignal::Transaction::HTTP_REQUEST)
       end
 
-      context "without an exception" do
-        it "create a transaction for the request" do
-          expect { make_request(env) }.to(change { created_transactions.count }.by(1))
+      context "without an error" do
+        before { make_request }
 
-          expect(last_transaction.to_h).to include(
-            "namespace" => Appsignal::Transaction::HTTP_REQUEST,
-            "action" => nil,
-            "error" => nil
-          )
+        it "calls the next middleware in the stack" do
+          expect(app).to be_called
         end
 
-        it "reports a process.abstract event" do
-          make_request(env)
+        it "does not record an error" do
+          expect(last_transaction).to_not have_error
+        end
 
-          expect(last_transaction.to_h).to include(
-            "events" => [
-              hash_including(
-                "body" => "",
-                "body_format" => Appsignal::EventFormatter::DEFAULT,
-                "count" => 1,
-                "name" => "process.abstract",
-                "title" => ""
-              )
-            ]
-          )
+        it "records an instrumentation event" do
+          expect(last_transaction).to include_event(:name => "process.abstract")
         end
 
         it "completes the transaction" do
-          make_request(env)
           expect(last_transaction).to be_completed
+          expect(Appsignal::Transaction.current)
+            .to be_kind_of(Appsignal::Transaction::NilTransaction)
+        end
+
+        context "when instrument_span_name option is nil" do
+          let(:options) { { :instrument_span_name => nil } }
+
+          it "does not record an instrumentation event" do
+            expect(last_transaction).to_not include_events
+          end
         end
       end
 
-      context "with an exception" do
+      context "with an error" do
         let(:error) { ExampleException.new("error message") }
-        before do
-          allow(app).to receive(:call).and_raise(error)
-          expect { make_request_with_error(env, error) }
+        let(:app) { lambda { |_env| raise ExampleException, "error message" } }
+
+        it "create a transaction for the request" do
+          expect { make_request_with_error(ExampleException, "error message") }
             .to(change { created_transactions.count }.by(1))
-        end
 
-        it "creates a transaction for the request and records the exception" do
-          expect(last_transaction.to_h).to include(
-            "error" => hash_including(
-              "name" => "ExampleException",
-              "message" => "error message"
-            )
-          )
+          expect(last_transaction).to have_namespace(Appsignal::Transaction::HTTP_REQUEST)
         end
 
-        it "completes the transaction" do
-          expect(last_transaction).to be_completed
+        describe "error" do
+          before do
+            make_request_with_error(ExampleException, "error message")
+          end
+
+          it "records the error" do
+            expect(last_transaction).to have_error("ExampleException", "error message")
+          end
+
+          it "completes the transaction" do
+            expect(last_transaction).to be_completed
+            expect(Appsignal::Transaction.current)
+              .to be_kind_of(Appsignal::Transaction::NilTransaction)
+          end
+
+          context "with :report_errors set to false" do
+            let(:app) { lambda { |_env| raise ExampleException, "error message" } }
+            let(:options) { { :report_errors => false } }
+
+            it "does not record the exception on the transaction" do
+              expect(last_transaction).to_not have_error
+            end
+          end
+
+          context "with :report_errors set to true" do
+            let(:app) { lambda { |_env| raise ExampleException, "error message" } }
+            let(:options) { { :report_errors => true } }
+
+            it "records the exception on the transaction" do
+              expect(last_transaction).to have_error("ExampleException", "error message")
+            end
+          end
+
+          context "with :report_errors set to a lambda that returns false" do
+            let(:app) { lambda { |_env| raise ExampleException, "error message" } }
+            let(:options) { { :report_errors => lambda { |_env| false } } }
+
+            it "does not record the exception on the transaction" do
+              expect(last_transaction).to_not have_error
+            end
+          end
+
+          context "with :report_errors set to a lambda that returns true" do
+            let(:app) { lambda { |_env| raise ExampleException, "error message" } }
+            let(:options) { { :report_errors => lambda { |_env| true } } }
+
+            it "records the exception on the transaction" do
+              expect(last_transaction).to have_error("ExampleException", "error message")
+            end
+          end
         end
       end
 
       context "without action name metadata" do
         it "reports no action name" do
-          make_request(env)
+          make_request
 
-          expect(last_transaction.to_h).to include("action" => nil)
+          expect(last_transaction).to_not have_action
         end
       end
 
       context "with appsignal.route env" do
-        before do
-          env["appsignal.route"] = "POST /my-route"
-        end
-
         it "reports the appsignal.route value as the action name" do
-          make_request(env)
+          env["appsignal.route"] = "POST /my-route"
+          make_request
 
-          expect(last_transaction.to_h).to include("action" => "POST /my-route")
+          expect(last_transaction).to have_action("POST /my-route")
         end
       end
 
       context "with appsignal.action env" do
-        before do
-          env["appsignal.action"] = "POST /my-action"
-        end
-
         it "reports the appsignal.route value as the action name" do
-          make_request(env)
+          env["appsignal.action"] = "POST /my-action"
+          make_request
 
-          expect(last_transaction.to_h).to include("action" => "POST /my-action")
+          expect(last_transaction).to have_action("POST /my-action")
         end
       end
 
       describe "request metadata" do
-        before do
-          env.merge("PATH_INFO" => "/some/path", "REQUEST_METHOD" => "GET")
-        end
-
         it "sets request metadata" do
-          make_request(env)
-
-          expect(last_transaction.to_h).to include(
-            "metadata" => {
-              "method" => "GET",
-              "path" => "/some/path"
-            },
-            "sample_data" => hash_including(
-              "environment" => hash_including(
-                "REQUEST_METHOD" => "GET",
-                "PATH_INFO" => "/some/path"
-                # and more, but we don't need to test Rack mock defaults
-              )
-            )
+          env.merge!("PATH_INFO" => "/some/path", "REQUEST_METHOD" => "GET")
+          make_request
+
+          expect(last_transaction).to include_metadata(
+            "method" => "GET",
+            "path" => "/some/path"
+          )
+          expect(last_transaction).to include_environment(
+            "REQUEST_METHOD" => "GET",
+            "PATH_INFO" => "/some/path"
+            # and more, but we don't need to test Rack mock defaults
           )
         end
 
+        context "with an invalid HTTP request method" do
+          it "stores the invalid HTTP request method" do
+            env["REQUEST_METHOD"] = "FOO"
+            make_request
+
+            expect(last_transaction).to include_metadata("method" => "FOO")
+          end
+        end
+
+        context "with fetching the request method raises an error" do
+          class BrokenRequestMethodRequest < Rack::Request
+            def request_method
+              raise "uh oh!"
+            end
+          end
+
+          let(:options) { { :request_class => BrokenRequestMethodRequest } }
+          it "does not store the invalid HTTP request method" do
+            env["REQUEST_METHOD"] = "FOO"
+            make_request
+
+            expect(last_transaction).to_not include_metadata("method" => anything)
+          end
+        end
+
         it "sets request parameters" do
-          make_request(env)
-
-          expect(last_transaction.to_h).to include(
-            "sample_data" => hash_including(
-              "params" => hash_including(
-                "page" => "2",
-                "query" => "lorem"
-              )
-            )
+          make_request
+
+          expect(last_transaction).to include_params(
+            "page" => "2",
+            "query" => "lorem"
           )
         end
+
+        context "when setting custom params" do
+          let(:app) do
+            DummyApp.new do |_env|
+              Appsignal::Transaction.current.set_params("custom" => "param")
+            end
+          end
+
+          it "allow custom request parameters to be set" do
+            make_request
+
+            expect(last_transaction).to include_params("custom" => "param")
+          end
+        end
       end
 
       context "with queue start header" do
         let(:queue_start_time) { fixed_time * 1_000 }
-        before do
-          env["HTTP_X_REQUEST_START"] = "t=#{queue_start_time.to_i}" # in milliseconds
-        end
 
         it "sets the queue start" do
-          make_request(env)
+          env["HTTP_X_REQUEST_START"] = "t=#{queue_start_time.to_i}" # in milliseconds
+          make_request
 
-          expect(last_transaction.ext.queue_start).to eq(queue_start_time)
+          expect(last_transaction).to have_queue_start(queue_start_time)
         end
       end
 
@@ -208,13 +267,9 @@ describe Appsignal::Rack::AbstractMiddleware do
         end
 
         it "uses the overridden request class and params method to fetch params" do
-          make_request(env)
+          make_request
 
-          expect(last_transaction.to_h).to include(
-            "sample_data" => hash_including(
-              "params" => { "abc" => "123" }
-            )
-          )
+          expect(last_transaction).to include_params("abc" => "123")
         end
       end
 
@@ -224,13 +279,23 @@ describe Appsignal::Rack::AbstractMiddleware do
         end
 
         it "uses the existing transaction" do
-          make_request(env)
+          make_request
 
-          expect { make_request(env) }.to_not(change { created_transactions.count })
+          expect { make_request }.to_not(change { created_transactions.count })
+        end
+
+        context "with error" do
+          let(:app) { lambda { |_env| raise ExampleException, "error message" } }
+
+          it "doesn't record the error on the transaction" do
+            make_request_with_error(ExampleException, "error message")
+
+            expect(last_transaction).to_not have_error
+          end
         end
 
         it "doesn't complete the existing transaction" do
-          make_request(env)
+          make_request
 
           expect(env[Appsignal::Rack::APPSIGNAL_TRANSACTION]).to_not be_completed
         end
@@ -239,9 +304,53 @@ describe Appsignal::Rack::AbstractMiddleware do
           it "does not overwrite the action name" do
             env[Appsignal::Rack::APPSIGNAL_TRANSACTION].set_action("My custom action")
             env["appsignal.action"] = "POST /my-action"
-            make_request(env)
+            make_request
+
+            expect(last_transaction).to have_action("My custom action")
+          end
+        end
+
+        context "with :report_errors set to false" do
+          let(:app) { lambda { |_env| raise ExampleException, "error message" } }
+          let(:options) { { :report_errors => false } }
+
+          it "does not record the error on the transaction" do
+            make_request_with_error(ExampleException, "error message")
+
+            expect(last_transaction).to_not have_error
+          end
+        end
+
+        context "with :report_errors set to true" do
+          let(:app) { lambda { |_env| raise ExampleException, "error message" } }
+          let(:options) { { :report_errors => true } }
+
+          it "records the error on the transaction" do
+            make_request_with_error(ExampleException, "error message")
+
+            expect(last_transaction).to have_error("ExampleException", "error message")
+          end
+        end
+
+        context "with :report_errors set to a lambda that returns false" do
+          let(:app) { lambda { |_env| raise ExampleException, "error message" } }
+          let(:options) { { :report_errors => lambda { |_env| false } } }
+
+          it "does not record the exception on the transaction" do
+            make_request_with_error(ExampleException, "error message")
+
+            expect(last_transaction).to_not have_error
+          end
+        end
+
+        context "with :report_errors set to a lambda that returns true" do
+          let(:app) { lambda { |_env| raise ExampleException, "error message" } }
+          let(:options) { { :report_errors => lambda { |_env| true } } }
+
+          it "records the error on the transaction" do
+            make_request_with_error(ExampleException, "error message")
 
-            expect(last_transaction.to_h).to include("action" => "My custom action")
+            expect(last_transaction).to have_error("ExampleException", "error message")
           end
         end
       end