appsignal 4.0.4-java → 4.0.5-java

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

@@ -1,34 +1,45 @@
 describe Appsignal::Hooks::PumaHook do
   context "with puma" do
-    before(:context) do
-      class Puma
-        def self.stats
-        end
+    let(:puma_version) { "6.0.0" }
+    before do
+      stub_const("Puma", PumaMock)
+      stub_const("Puma::Const::VERSION", puma_version)
+    end
+
+    describe "#dependencies_present?" do
+      subject { described_class.new.dependencies_present? }
+
+      context "when Puma present" do
+        context "when Puma is newer than version 3.0.0" do
+          let(:puma_version) { "3.0.0" }
 
-        def self.cli_config
-          @cli_config ||= CliConfig.new
+          it { is_expected.to be_truthy }
         end
-      end
 
-      class CliConfig
-        attr_accessor :options
+        context "when Puma is older than version 3.0.0" do
+          let(:puma_version) { "2.9.9" }
 
-        def initialize
-          @options = {}
+          it { is_expected.to be_falsey }
         end
       end
-    end
-    after(:context) { Object.send(:remove_const, :Puma) }
 
-    describe "#dependencies_present?" do
-      subject { described_class.new.dependencies_present? }
+      context "when Puma is not present" do
+        before do
+          hide_const("Puma")
+        end
 
-      it { is_expected.to be_truthy }
+        it { is_expected.to be_falsey }
+      end
     end
 
     describe "installation" do
       before { Appsignal::Probes.probes.clear }
 
+      it "adds the Puma::Server patch" do
+        Appsignal::Hooks::PumaHook.new.install
+        expect(::Puma::Server.included_modules).to include(Appsignal::Integrations::PumaServer)
+      end
+
       context "when not clustered mode" do
         it "does not add AppSignal stop behavior Puma::Cluster" do
           expect(defined?(::Puma::Cluster)).to be_falsy
@@ -39,15 +50,12 @@ describe Appsignal::Hooks::PumaHook do
 
       context "when in clustered mode" do
         before do
-          class Puma
-            class Cluster
-              def stop_workers
-                @called = true
-              end
+          stub_const("Puma::Cluster", Class.new do
+            def stop_workers
+              @called = true
             end
-          end
+          end)
         end
-        after { Puma.send(:remove_const, :Cluster) }
 
         it "adds behavior to Puma::Cluster.stop_workers" do
           Appsignal::Hooks::PumaHook.new.install

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

@@ -0,0 +1,150 @@
+require "appsignal/integrations/puma"
+
+describe Appsignal::Integrations::PumaServer do
+  describe "#lowlevel_error" do
+    before do
+      stub_const("Puma", PumaMock)
+      stub_const("Puma::Server", puma_server)
+      start_agent
+    end
+    let(:queue_start_time) { fixed_time * 1_000 }
+    let(:env) do
+      Rack::MockRequest.env_for(
+        "/some/path",
+        "REQUEST_METHOD" => "GET",
+        :params => { "page" => 2, "query" => "lorem" },
+        "rack.session" => { "session" => "data", "user_id" => 123 },
+        "HTTP_X_REQUEST_START" => "t=#{queue_start_time.to_i}" # in milliseconds
+      )
+    end
+    let(:server) { Puma::Server.new }
+    let(:error) { ExampleException.new("error message") }
+    around { |example| keep_transactions { example.run } }
+    before { Appsignal::Hooks::PumaHook.new.install }
+
+    def lowlevel_error(error, env, status = nil)
+      result =
+        if status
+          server.lowlevel_error(error, env, status)
+        else
+          server.lowlevel_error(error, env)
+        end
+      # Transaction is normally closed by the EventHandler's RACK_AFTER_REPLY hook
+      last_transaction&.complete
+      result
+    end
+
+    describe "error reporting" do
+      let(:puma_server) { default_puma_server_mock }
+
+      context "with active transaction" do
+        before { create_transaction }
+
+        it "reports the error to the transaction" do
+          expect do
+            lowlevel_error(error, env)
+          end.to_not(change { created_transactions.count })
+
+          expect(last_transaction).to have_error("ExampleException", "error message")
+          expect(last_transaction).to include_tags("reported_by" => "puma_lowlevel_error")
+        end
+      end
+
+      # This shouldn't happen if the EventHandler is set up correctly, but if
+      # it's not it will create a new transaction.
+      context "without active transaction" do
+        it "creates a new transaction with the error" do
+          expect do
+            lowlevel_error(error, env)
+          end.to change { created_transactions.count }.by(1)
+
+          expect(last_transaction).to have_error("ExampleException", "error message")
+          expect(last_transaction).to include_tags("reported_by" => "puma_lowlevel_error")
+        end
+      end
+
+      it "doesn't report internal Puma errors" do
+        expect do
+          lowlevel_error(Puma::MiniSSL::SSLError.new("error message"), env)
+          lowlevel_error(Puma::HttpParserError.new("error message"), env)
+          lowlevel_error(Puma::HttpParserError501.new("error message"), env)
+        end.to_not(change { created_transactions.count })
+      end
+
+      describe "request metadata" do
+        it "sets request metadata" do
+          lowlevel_error(error, env)
+
+          expect(last_transaction).to include_metadata(
+            "request_method" => "GET",
+            "method" => "GET",
+            "request_path" => "/some/path",
+            "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
+
+        it "sets request parameters" do
+          lowlevel_error(error, env)
+
+          expect(last_transaction).to include_params(
+            "page" => "2",
+            "query" => "lorem"
+          )
+        end
+
+        it "sets session data" do
+          lowlevel_error(error, env)
+
+          expect(last_transaction).to include_session_data("session" => "data", "user_id" => 123)
+        end
+
+        it "sets the queue start" do
+          lowlevel_error(error, env)
+
+          expect(last_transaction).to have_queue_start(queue_start_time)
+        end
+      end
+    end
+
+    context "with Puma::Server#lowlevel_error accepting 3 arguments" do
+      let(:puma_server) { default_puma_server_mock }
+
+      it "calls the super class with 3 arguments" do
+        result = lowlevel_error(error, env, 501)
+        expect(result).to eq([501, {}, ""])
+
+        expect(last_transaction).to include_tags("response_status" => 501)
+      end
+    end
+
+    context "with Puma::Server#lowlevel_error accepting 2 arguments" do
+      let(:puma_server) do
+        Class.new do
+          def lowlevel_error(_error, _env)
+            [500, {}, ""]
+          end
+        end
+      end
+
+      it "calls the super class with 3 arguments" do
+        result = lowlevel_error(error, env)
+        expect(result).to eq([500, {}, ""])
+
+        expect(last_transaction).to include_tags("response_status" => 500)
+      end
+    end
+  end
+
+  def default_puma_server_mock
+    Class.new do
+      def lowlevel_error(_error, _env, status = 500)
+        [status, {}, ""]
+      end
+    end
+  end
+end

data/spec/lib/appsignal/probes_spec.rb

@@ -244,12 +244,7 @@ describe Appsignal::Probes do
   end
 
   describe ".unregister" do
-    let(:log_stream) { StringIO.new }
-    let(:log) { log_contents(log_stream) }
-    before do
-      Appsignal.internal_logger = test_logger(log_stream)
-      speed_up_tests!
-    end
+    before { speed_up_tests! }
 
     it "does not call the initialized probe after unregistering" do
       probe1_calls = 0

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

@@ -1,19 +1,8 @@
 describe Appsignal::Rack::AbstractMiddleware do
-  class HashLike < Hash
-    def initialize(value)
-      @value = value
-    end
-
-    def to_h
-      @value
-    end
-  end
-
   let(:app) { DummyApp.new }
-  let(:request_path) { "/some/path" }
   let(:env) do
     Rack::MockRequest.env_for(
-      request_path,
+      "/some/path",
       "REQUEST_METHOD" => "GET",
       :params => { "page" => 2, "query" => "lorem" },
       "rack.session" => { "session" => "data", "user_id" => 123 }
@@ -174,13 +163,17 @@ describe Appsignal::Rack::AbstractMiddleware do
         end
       end
 
+      # Partial duplicate tests from Appsignal::Rack::ApplyRackRequest that
+      # ensure the request metadata is set on via the AbstractMiddleware.
       describe "request metadata" do
         it "sets request metadata" do
           env.merge!("PATH_INFO" => "/some/path", "REQUEST_METHOD" => "GET")
           make_request
 
           expect(last_transaction).to include_metadata(
+            "request_method" => "GET",
             "method" => "GET",
+            "request_path" => "/some/path",
             "path" => "/some/path"
           )
           expect(last_transaction).to include_environment(
@@ -190,36 +183,6 @@ describe Appsignal::Rack::AbstractMiddleware do
           )
         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 "when 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"
-            logs = capture_logs { make_request }
-
-            expect(last_transaction).to_not include_metadata("method" => anything)
-            expect(logs).to contains_log(
-              :error,
-              "Exception while fetching the HTTP request method: RuntimeError: uh oh"
-            )
-          end
-        end
-
         it "sets request parameters" do
           make_request
 
@@ -229,107 +192,63 @@ describe Appsignal::Rack::AbstractMiddleware do
           )
         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
-
-        context "when fetching the request method raises an error" do
-          class BrokenRequestParamsRequest < Rack::Request
-            def params
-              raise "uh oh!"
-            end
-          end
-
-          let(:options) do
-            { :request_class => BrokenRequestParamsRequest, :params_method => :params }
-          end
-
-          it "does not store the invalid HTTP request method" do
-            logs = capture_logs { make_request }
-
-            expect(last_transaction).to_not include_params
-            expect(logs).to contains_log(
-              :error,
-              "Exception while fetching params " \
-                "from 'BrokenRequestParamsRequest#params': RuntimeError uh oh!"
-            )
-          end
-        end
-
         it "sets session data" do
           make_request
 
           expect(last_transaction).to include_session_data("session" => "data", "user_id" => 123)
         end
 
-        it "sets session data if the session is a Hash-like type" do
-          env["rack.session"] = HashLike.new("hash-like" => "value", "user_id" => 123)
-          make_request
-
-          expect(last_transaction).to include_session_data("hash-like" => "value", "user_id" => 123)
-        end
-      end
-
-      context "with queue start header" do
-        let(:queue_start_time) { fixed_time * 1_000 }
+        context "with queue start header" do
+          let(:queue_start_time) { fixed_time * 1_000 }
 
-        it "sets the queue start" do
-          env["HTTP_X_REQUEST_START"] = "t=#{queue_start_time.to_i}" # in milliseconds
-          make_request
+          it "sets the queue start" do
+            env["HTTP_X_REQUEST_START"] = "t=#{queue_start_time.to_i}" # in milliseconds
+            make_request
 
-          expect(last_transaction).to have_queue_start(queue_start_time)
+            expect(last_transaction).to have_queue_start(queue_start_time)
+          end
         end
-      end
 
-      class FilteredRequest
-        attr_reader :env
+        class SomeFilteredRequest
+          attr_reader :env
 
-        def initialize(env)
-          @env = env
-        end
+          def initialize(env)
+            @env = env
+          end
 
-        def path
-          "/static/path"
-        end
+          def path
+            "/static/path"
+          end
 
-        def request_method
-          "GET"
-        end
+          def request_method
+            "GET"
+          end
 
-        def filtered_params
-          { "abc" => "123" }
-        end
+          def filtered_params
+            { "abc" => "123" }
+          end
 
-        def session
-          { "data" => "value" }
+          def session
+            { "data" => "value" }
+          end
         end
-      end
 
-      context "with overridden request class and params method" do
-        let(:options) do
-          { :request_class => FilteredRequest, :params_method => :filtered_params }
-        end
+        context "with overridden request class and params method" do
+          let(:options) do
+            { :request_class => SomeFilteredRequest, :params_method => :filtered_params }
+          end
 
-        it "uses the overridden request class and params method to fetch params" do
-          make_request
+          it "uses the overridden request class and params method to fetch params" do
+            make_request
 
-          expect(last_transaction).to include_params("abc" => "123")
-        end
+            expect(last_transaction).to include_params("abc" => "123")
+          end
 
-        it "uses the overridden request class to fetch session data" do
-          make_request
+          it "uses the overridden request class to fetch session data" do
+            make_request
 
-          expect(last_transaction).to include_session_data("data" => "value")
+            expect(last_transaction).to include_session_data("data" => "value")
+          end
         end
       end
 

data/spec/lib/appsignal/rack_spec.rb

@@ -61,3 +61,183 @@ describe Appsignal::Rack::Utils do
     end
   end
 end
+
+describe Appsignal::Rack::ApplyRackRequest do
+  describe "#apply_to" do
+    let(:merged_env) do
+      Rack::MockRequest.env_for(
+        "/some/path",
+        {
+          "REQUEST_METHOD" => "GET",
+          :params => { "page" => 2, "query" => "lorem" },
+          "rack.session" => { "session" => "data", "user_id" => 123 }
+        }.merge(env)
+      )
+    end
+    let(:env) { {} }
+    let(:request) { ::Rack::Request.new(merged_env) }
+    let(:options) { {} }
+    let(:helper) { described_class.new(request, options) }
+    let(:transaction) { http_request_transaction }
+    before { start_agent }
+
+    def apply_to(transaction)
+      helper.apply_to(transaction)
+      transaction._sample
+    end
+
+    it "sets request metadata" do
+      apply_to(transaction)
+
+      expect(transaction).to include_metadata(
+        "method" => "GET",
+        "path" => "/some/path"
+      )
+      expect(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
+      let(:env) { { "REQUEST_METHOD" => "FOO" } }
+
+      it "stores the invalid HTTP request method" do
+        apply_to(transaction)
+
+        expect(transaction).to include_metadata("method" => "FOO")
+      end
+    end
+
+    context "when fetching the request method raises an error" do
+      class BrokenRequestMethodRequest < Rack::Request
+        def request_method
+          raise "uh oh!"
+        end
+      end
+
+      let(:env) { { "REQUEST_METHOD" => "FOO" } }
+      let(:request) { BrokenRequestMethodRequest.new(merged_env) }
+
+      it "does not store the invalid HTTP request method" do
+        logs = capture_logs { apply_to(transaction) }
+
+        expect(transaction).to_not include_metadata("method" => anything)
+        expect(logs).to contains_log(
+          :error,
+          "Exception while fetching the HTTP request method: RuntimeError: uh oh"
+        )
+      end
+    end
+
+    it "sets request parameters" do
+      apply_to(transaction)
+
+      expect(transaction).to include_params(
+        "page" => "2",
+        "query" => "lorem"
+      )
+    end
+
+    context "when params_method isn't set" do
+      let(:options) { { :params_method => nil } }
+
+      it "reports no params" do
+        apply_to(transaction)
+
+        expect(transaction).to_not include_params
+      end
+    end
+
+    context "when fetching the request method raises an error" do
+      class BrokenRequestParamsRequest < Rack::Request
+        def params
+          raise "uh oh!"
+        end
+      end
+
+      let(:request) { BrokenRequestParamsRequest.new(merged_env) }
+      let(:options) { { :params_method => :params } }
+
+      it "does not store the invalid HTTP request method" do
+        logs = capture_logs { apply_to(transaction) }
+
+        expect(transaction).to_not include_params
+        expect(logs).to contains_log(
+          :error,
+          "Exception while fetching params " \
+            "from 'BrokenRequestParamsRequest#params': RuntimeError uh oh!"
+        )
+      end
+    end
+
+    it "sets session data" do
+      apply_to(transaction)
+
+      expect(transaction).to include_session_data("session" => "data", "user_id" => 123)
+    end
+
+    context "with Hash-like session data" do
+      let(:env) { { "rack.session" => HashLike.new("hash-like" => "value", "user_id" => 123) } }
+
+      it "sets session data" do
+        apply_to(transaction)
+
+        expect(transaction).to include_session_data("hash-like" => "value", "user_id" => 123)
+      end
+    end
+
+    context "with queue start header" do
+      let(:queue_start_time) { fixed_time * 1_000 }
+      let(:env) { { "HTTP_X_REQUEST_START" => "t=#{queue_start_time.to_i}" } } # in milliseconds
+
+      it "sets the queue start" do
+        apply_to(transaction)
+
+        expect(transaction).to have_queue_start(queue_start_time)
+      end
+    end
+
+    class RackFilteredRequest
+      attr_reader :env
+
+      def initialize(env)
+        @env = env
+      end
+
+      def path
+        "/static/path"
+      end
+
+      def request_method
+        "GET"
+      end
+
+      def filtered_params
+        { "abc" => "123" }
+      end
+
+      def session
+        { "data" => "value" }
+      end
+    end
+
+    context "with overridden request class and params method" do
+      let(:request) { RackFilteredRequest.new(env) }
+      let(:options) { { :params_method => :filtered_params } }
+
+      it "uses the overridden request class and params method to fetch params" do
+        apply_to(transaction)
+
+        expect(transaction).to include_params("abc" => "123")
+      end
+
+      it "uses the overridden request class to fetch session data" do
+        apply_to(transaction)
+
+        expect(transaction).to include_session_data("data" => "value")
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -168,13 +168,6 @@ RSpec.configure do |config|
   end
 
   def stop_minutely_probes
-    thread =
-      begin
-        Appsignal::Probes.class_variable_get(:@@thread) # Fetch old thread
-      rescue NameError
-        nil
-      end
     Appsignal::Probes.stop
-    thread&.join # Wait for old thread to exit
   end
 end

data/spec/support/helpers/config_helpers.rb

@@ -46,7 +46,7 @@ module ConfigHelpers
   end
   module_function :build_config
 
-  def start_agent(env: "production", options: {})
+  def start_agent(env: "production", options: {}, internal_logger: nil)
     env = "production" if env == :default
     env ||= "production"
     Appsignal.configure(env, :root_path => project_fixture_path) do |config|
@@ -55,6 +55,7 @@ module ConfigHelpers
       end
     end
     Appsignal.start
+    Appsignal.internal_logger = internal_logger if internal_logger
   end
 
   def clear_integration_env_vars!