appsignal 3.9.3-java → 3.11.0-java

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

@@ -15,31 +15,64 @@ if DependencyHelper.webmachine_present?
 
   describe Appsignal::Integrations::WebmachineIntegration do
     let(:request) do
-      Webmachine::Request.new("GET", "http://google.com:80/foo", {}, nil)
+      Webmachine::Request.new(
+        "GET",
+        "http://google.com:80/foo?param1=value1&param2=value2",
+        {
+          "REQUEST_METHOD" => "GET",
+          "PATH_INFO" => "/some/path",
+          "ignored_header" => "something"
+        },
+        nil
+      )
     end
-    let(:resource) { double(:trace? => false, :handle_exception => true, :"code=" => nil) }
-    let(:response) { Response.new }
-    let(:fsm) { Webmachine::Decision::FSM.new(resource, request, response) }
-    before(:context) { start_agent }
-    around { |example| keep_transactions { example.run } }
+    let(:app) do
+      proc do
+        def to_html
+          "Some HTML"
+        end
+      end
+    end
+    let(:resource) do
+      app_block = app
+      Class.new(Webmachine::Resource) do
+        class_eval(&app_block) if app_block
 
-    # Make sure the request responds to the method we need to get query params.
-    describe "request" do
-      it "responds to #query" do
-        expect(request).to respond_to(:query)
+        def self.name
+          "MyResource"
+        end
       end
     end
+    let(:resource_instance) { resource.new(request, response) }
+    let(:response) { Webmachine::Response.new }
+    let(:fsm) { Webmachine::Decision::FSM.new(resource_instance, request, response) }
+    before { start_agent }
+    around { |example| keep_transactions { example.run } }
 
     describe "#run" do
-      before { allow(fsm).to receive(:call).and_call_original }
-
       it "creates a transaction" do
         expect { fsm.run }.to(change { created_transactions.count }.by(1))
       end
 
       it "sets the action" do
         fsm.run
-        expect(last_transaction).to have_action("RSpec::Mocks::Double#GET")
+        expect(last_transaction).to have_action("MyResource#GET")
+      end
+
+      context "with action already set" do
+        let(:app) do
+          proc do
+            def to_html
+              Appsignal.set_action("Custom Action")
+              "Some HTML"
+            end
+          end
+        end
+
+        it "doesn't overwrite the action" do
+          fsm.run
+          expect(last_transaction).to have_action("Custom Action")
+        end
       end
 
       it "records an instrumentation event" do
@@ -47,16 +80,43 @@ if DependencyHelper.webmachine_present?
         expect(last_transaction).to include_event("name" => "process_action.webmachine")
       end
 
+      it "sets the params" do
+        fsm.run
+        expect(last_transaction).to include_params("param1" => "value1", "param2" => "value2")
+      end
+
+      it "sets the headers" do
+        fsm.run
+        expect(last_transaction).to include_environment(
+          "REQUEST_METHOD" => "GET",
+          "PATH_INFO" => "/some/path"
+        )
+      end
+
       it "closes the transaction" do
         fsm.run
         expect(last_transaction).to be_completed
         expect(current_transaction?).to be_falsy
       end
 
-      it "sets a response code" do
-        expect(fsm.response.code).to be_nil
-        fsm.run
-        expect(fsm.response.code).not_to be_nil
+      context "with parent transaction" do
+        let(:transaction) { http_request_transaction }
+        before { set_current_transaction(transaction) }
+
+        it "sets the action" do
+          fsm.run
+          expect(last_transaction).to have_action("MyResource#GET")
+        end
+
+        it "sets the params" do
+          fsm.run
+          last_transaction._sample
+          expect(last_transaction).to include_params("param1" => "value1", "param2" => "value2")
+        end
+
+        it "does not close the transaction" do
+          expect(last_transaction).to_not be_completed
+        end
       end
     end
 

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

@@ -5,7 +5,8 @@ describe Appsignal::Rack::AbstractMiddleware do
     Rack::MockRequest.env_for(
       request_path,
       "REQUEST_METHOD" => "GET",
-      :params => { "page" => 2, "query" => "lorem" }
+      :params => { "page" => 2, "query" => "lorem" },
+      "rack.session" => { "session" => "data", "user_id" => 123 }
     )
   end
   let(:options) { {} }
@@ -45,6 +46,11 @@ describe Appsignal::Rack::AbstractMiddleware do
         expect(last_transaction).to have_namespace(Appsignal::Transaction::HTTP_REQUEST)
       end
 
+      it "wraps the response body in a BodyWrapper subclass" do
+        _status, _headers, body = make_request
+        expect(body).to be_kind_of(Appsignal::Rack::BodyWrapper)
+      end
+
       context "without an error" do
         before { make_request }
 
@@ -56,8 +62,20 @@ describe Appsignal::Rack::AbstractMiddleware do
           expect(last_transaction).to_not have_error
         end
 
-        it "records an instrumentation event" do
-          expect(last_transaction).to include_event(:name => "process.abstract")
+        context "without :instrument_event_name option set" do
+          let(:options) { {} }
+
+          it "does not record an instrumentation event" do
+            expect(last_transaction).to_not include_event
+          end
+        end
+
+        context "with :instrument_event_name option set" do
+          let(:options) { { :instrument_event_name => "event_name.category" } }
+
+          it "records an instrumentation event" do
+            expect(last_transaction).to include_event(:name => "event_name.category")
+          end
         end
 
         it "completes the transaction" do
@@ -66,8 +84,8 @@ describe Appsignal::Rack::AbstractMiddleware do
             .to be_kind_of(Appsignal::Transaction::NilTransaction)
         end
 
-        context "when instrument_span_name option is nil" do
-          let(:options) { { :instrument_span_name => nil } }
+        context "when instrument_event_name option is nil" do
+          let(:options) { { :instrument_event_name => nil } }
 
           it "does not record an instrumentation event" do
             expect(last_transaction).to_not include_events
@@ -148,21 +166,61 @@ describe Appsignal::Rack::AbstractMiddleware do
       end
 
       context "with appsignal.route env" do
+        before { env["appsignal.route"] = "POST /my-route" }
+
         it "reports the appsignal.route value as the action name" do
-          env["appsignal.route"] = "POST /my-route"
           make_request
 
           expect(last_transaction).to have_action("POST /my-route")
         end
+
+        it "prints a deprecation warning" do
+          err_stream = std_stream
+          capture_std_streams(std_stream, err_stream) do
+            make_request
+          end
+
+          expect(err_stream.read).to include(
+            "Setting the action name with the request env 'appsignal.route' is deprecated."
+          )
+        end
+
+        it "logs a deprecation warning" do
+          logs = capture_logs { make_request }
+          expect(logs).to contains_log(
+            :warn,
+            "Setting the action name with the request env 'appsignal.route' is deprecated."
+          )
+        end
       end
 
       context "with appsignal.action env" do
-        it "reports the appsignal.route value as the action name" do
-          env["appsignal.action"] = "POST /my-action"
+        before { env["appsignal.action"] = "POST /my-action" }
+
+        it "reports the appsignal.action value as the action name" do
           make_request
 
           expect(last_transaction).to have_action("POST /my-action")
         end
+
+        it "prints a deprecation warning" do
+          err_stream = std_stream
+          capture_std_streams(std_stream, err_stream) do
+            make_request
+          end
+
+          expect(err_stream.read).to include(
+            "Setting the action name with the request env 'appsignal.action' is deprecated."
+          )
+        end
+
+        it "logs a deprecation warning" do
+          logs = capture_logs { make_request }
+          expect(logs).to contains_log(
+            :warn,
+            "Setting the action name with the request env 'appsignal.action' is deprecated."
+          )
+        end
       end
 
       describe "request metadata" do
@@ -190,7 +248,7 @@ describe Appsignal::Rack::AbstractMiddleware do
           end
         end
 
-        context "with fetching the request method raises an error" do
+        context "when fetching the request method raises an error" do
           class BrokenRequestMethodRequest < Rack::Request
             def request_method
               raise "uh oh!"
@@ -198,11 +256,16 @@ describe Appsignal::Rack::AbstractMiddleware do
           end
 
           let(:options) { { :request_class => BrokenRequestMethodRequest } }
+
           it "does not store the invalid HTTP request method" do
             env["REQUEST_METHOD"] = "FOO"
-            make_request
+            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
 
@@ -228,6 +291,35 @@ describe Appsignal::Rack::AbstractMiddleware do
             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
       end
 
       context "with queue start header" do
@@ -259,6 +351,10 @@ describe Appsignal::Rack::AbstractMiddleware do
         def filtered_params
           { "abc" => "123" }
         end
+
+        def session
+          { "data" => "value" }
+        end
       end
 
       context "with overridden request class and params method" do
@@ -271,11 +367,19 @@ describe Appsignal::Rack::AbstractMiddleware do
 
           expect(last_transaction).to include_params("abc" => "123")
         end
+
+        it "uses the overridden request class to fetch session data" do
+          make_request
+
+          expect(last_transaction).to include_session_data("data" => "value")
+        end
       end
 
       context "with parent instrumentation" do
+        let(:transaction) { http_request_transaction }
         before do
-          env[Appsignal::Rack::APPSIGNAL_TRANSACTION] = http_request_transaction
+          env[Appsignal::Rack::APPSIGNAL_TRANSACTION] = transaction
+          set_current_transaction(transaction)
         end
 
         it "uses the existing transaction" do
@@ -284,6 +388,35 @@ describe Appsignal::Rack::AbstractMiddleware do
           expect { make_request }.to_not(change { created_transactions.count })
         end
 
+        it "wraps the response body in a BodyWrapper subclass" do
+          _status, _headers, body = make_request
+          expect(body).to be_kind_of(Appsignal::Rack::BodyWrapper)
+
+          body.to_ary
+          response_events =
+            last_transaction.to_h["events"].count do |event|
+              event["name"] == "process_response_body.rack"
+            end
+          expect(response_events).to eq(1)
+        end
+
+        context "when response body is already a BodyWrapper subclass" do
+          let(:body) { Appsignal::Rack::BodyWrapper.wrap(["hello!"], transaction) }
+          let(:app) { DummyApp.new { [200, {}, body] } }
+
+          it "doesn't wrap the body again" do
+            _status, _headers, body = make_request
+            expect(body).to eq(body)
+
+            body.to_ary
+            response_events =
+              last_transaction.to_h["events"].count do |event|
+                event["name"] == "process_response_body.rack"
+              end
+            expect(response_events).to eq(1)
+          end
+        end
+
         context "with error" do
           let(:app) { lambda { |_env| raise ExampleException, "error message" } }
 

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

@@ -0,0 +1,263 @@
+describe Appsignal::Rack::BodyWrapper do
+  let(:transaction) { http_request_transaction }
+  before do
+    start_agent
+    set_current_transaction(transaction)
+  end
+
+  describe "with a body that supports all possible features" do
+    it "reduces the supported methods to just each()" do
+      # which is the safest thing to do, since the body is likely broken
+      fake_body = double(
+        :each => nil,
+        :call => nil,
+        :to_ary => [],
+        :to_path => "/tmp/foo.bin",
+        :close => nil
+      )
+
+      wrapped = described_class.wrap(fake_body, transaction)
+      expect(wrapped).to respond_to(:each)
+      expect(wrapped).to_not respond_to(:to_ary)
+      expect(wrapped).to_not respond_to(:call)
+      expect(wrapped).to respond_to(:close)
+    end
+  end
+
+  describe "with a body only supporting each()" do
+    it "wraps with appropriate class" do
+      fake_body = double(:each => nil)
+
+      wrapped = described_class.wrap(fake_body, transaction)
+      expect(wrapped).to respond_to(:each)
+      expect(wrapped).to_not respond_to(:to_ary)
+      expect(wrapped).to_not respond_to(:call)
+      expect(wrapped).to respond_to(:close)
+    end
+
+    it "reads out the body in full using each" do
+      fake_body = double
+      expect(fake_body).to receive(:each).once.and_yield("a").and_yield("b").and_yield("c")
+
+      wrapped = described_class.wrap(fake_body, transaction)
+      expect { |b| wrapped.each(&b) }.to yield_successive_args("a", "b", "c")
+
+      expect(transaction).to include_event(
+        "name" => "process_response_body.rack",
+        "title" => "Process Rack response body (#each)"
+      )
+    end
+
+    it "returns an Enumerator if each() gets called without a block" do
+      fake_body = double
+      expect(fake_body).to receive(:each).once.and_yield("a").and_yield("b").and_yield("c")
+
+      wrapped = described_class.wrap(fake_body, transaction)
+      enum = wrapped.each
+      expect(enum).to be_kind_of(Enumerator)
+      expect { |b| enum.each(&b) }.to yield_successive_args("a", "b", "c")
+
+      expect(transaction).to_not include_event("name" => "process_response_body.rack")
+    end
+
+    it "sets the exception raised inside each() on the transaction" do
+      fake_body = double
+      expect(fake_body).to receive(:each).once.and_raise(ExampleException, "error message")
+
+      wrapped = described_class.wrap(fake_body, transaction)
+      expect do
+        expect { |b| wrapped.each(&b) }.to yield_control
+      end.to raise_error(ExampleException, "error message")
+
+      expect(transaction).to have_error("ExampleException", "error message")
+    end
+
+    it "closes the body and tracks an instrumentation event when it gets closed" do
+      fake_body = double(:close => nil)
+      expect(fake_body).to receive(:each).once.and_yield("a").and_yield("b").and_yield("c")
+
+      wrapped = described_class.wrap(fake_body, transaction)
+      expect { |b| wrapped.each(&b) }.to yield_successive_args("a", "b", "c")
+      wrapped.close
+
+      expect(transaction).to include_event("name" => "close_response_body.rack")
+    end
+  end
+
+  describe "with a body supporting both each() and call" do
+    it "wraps with the wrapper that conceals call() and exposes each" do
+      fake_body = double
+      allow(fake_body).to receive(:each)
+      allow(fake_body).to receive(:call)
+
+      wrapped = described_class.wrap(fake_body, transaction)
+      expect(wrapped).to respond_to(:each)
+      expect(wrapped).to_not respond_to(:to_ary)
+      expect(wrapped).to_not respond_to(:call)
+      expect(wrapped).to_not respond_to(:to_path)
+      expect(wrapped).to respond_to(:close)
+    end
+  end
+
+  describe "with a body supporting both to_ary and each" do
+    let(:fake_body) { double(:each => nil, :to_ary => []) }
+
+    it "wraps with appropriate class" do
+      wrapped = described_class.wrap(fake_body, transaction)
+      expect(wrapped).to respond_to(:each)
+      expect(wrapped).to respond_to(:to_ary)
+      expect(wrapped).to_not respond_to(:call)
+      expect(wrapped).to_not respond_to(:to_path)
+      expect(wrapped).to respond_to(:close)
+    end
+
+    it "reads out the body in full using each" do
+      expect(fake_body).to receive(:each).once.and_yield("a").and_yield("b").and_yield("c")
+
+      wrapped = described_class.wrap(fake_body, transaction)
+      expect { |b| wrapped.each(&b) }.to yield_successive_args("a", "b", "c")
+
+      expect(transaction).to include_event(
+        "name" => "process_response_body.rack",
+        "title" => "Process Rack response body (#each)"
+      )
+    end
+
+    it "sets the exception raised inside each() into the Appsignal transaction" do
+      expect(fake_body).to receive(:each).once.and_raise(ExampleException, "error message")
+
+      wrapped = described_class.wrap(fake_body, transaction)
+      expect do
+        expect { |b| wrapped.each(&b) }.to yield_control
+      end.to raise_error(ExampleException, "error message")
+
+      expect(transaction).to have_error("ExampleException", "error message")
+    end
+
+    it "reads out the body in full using to_ary" do
+      expect(fake_body).to receive(:to_ary).and_return(["one", "two", "three"])
+
+      wrapped = described_class.wrap(fake_body, transaction)
+      expect(wrapped.to_ary).to eq(["one", "two", "three"])
+
+      expect(transaction).to include_event(
+        "name" => "process_response_body.rack",
+        "title" => "Process Rack response body (#to_ary)"
+      )
+    end
+
+    it "sends the exception raised inside to_ary() into the Appsignal and closes transaction" do
+      fake_body = double
+      allow(fake_body).to receive(:each)
+      expect(fake_body).to receive(:to_ary).once.and_raise(ExampleException, "error message")
+      expect(fake_body).to_not receive(:close) # Per spec we expect the body has closed itself
+
+      wrapped = described_class.wrap(fake_body, transaction)
+      expect do
+        wrapped.to_ary
+      end.to raise_error(ExampleException, "error message")
+
+      expect(transaction).to have_error("ExampleException", "error message")
+    end
+  end
+
+  describe "with a body supporting both to_path and each" do
+    let(:fake_body) { double(:each => nil, :to_path => nil) }
+
+    it "wraps with appropriate class" do
+      wrapped = described_class.wrap(fake_body, transaction)
+      expect(wrapped).to respond_to(:each)
+      expect(wrapped).to_not respond_to(:to_ary)
+      expect(wrapped).to_not respond_to(:call)
+      expect(wrapped).to respond_to(:to_path)
+      expect(wrapped).to respond_to(:close)
+    end
+
+    it "reads out the body in full using each()" do
+      expect(fake_body).to receive(:each).once.and_yield("a").and_yield("b").and_yield("c")
+
+      wrapped = described_class.wrap(fake_body, transaction)
+      expect { |b| wrapped.each(&b) }.to yield_successive_args("a", "b", "c")
+
+      expect(transaction).to include_event(
+        "name" => "process_response_body.rack",
+        "title" => "Process Rack response body (#each)"
+      )
+    end
+
+    it "sets the exception raised inside each() into the Appsignal transaction" do
+      expect(fake_body).to receive(:each).once.and_raise(ExampleException, "error message")
+
+      wrapped = described_class.wrap(fake_body, transaction)
+      expect do
+        expect { |b| wrapped.each(&b) }.to yield_control
+      end.to raise_error(ExampleException, "error message")
+
+      expect(transaction).to have_error("ExampleException", "error message")
+    end
+
+    it "sets the exception raised inside to_path() into the Appsignal transaction" do
+      allow(fake_body).to receive(:to_path).once.and_raise(ExampleException, "error message")
+
+      wrapped = described_class.wrap(fake_body, transaction)
+      expect do
+        wrapped.to_path
+      end.to raise_error(ExampleException, "error message")
+
+      expect(transaction).to have_error("ExampleException", "error message")
+    end
+
+    it "exposes to_path to the sender" do
+      allow(fake_body).to receive(:to_path).and_return("/tmp/file.bin")
+
+      wrapped = described_class.wrap(fake_body, transaction)
+      expect(wrapped.to_path).to eq("/tmp/file.bin")
+
+      expect(transaction).to include_event(
+        "name" => "process_response_body.rack",
+        "title" => "Process Rack response body (#to_path)"
+      )
+    end
+  end
+
+  describe "with a body only supporting call()" do
+    let(:fake_body) { double(:call => nil) }
+
+    it "wraps with appropriate class" do
+      wrapped = described_class.wrap(fake_body, transaction)
+      expect(wrapped).to_not respond_to(:each)
+      expect(wrapped).to_not respond_to(:to_ary)
+      expect(wrapped).to respond_to(:call)
+      expect(wrapped).to_not respond_to(:to_path)
+      expect(wrapped).to respond_to(:close)
+    end
+
+    it "passes the stream into the call() of the body" do
+      fake_rack_stream = double("stream")
+      expect(fake_body).to receive(:call).with(fake_rack_stream)
+
+      wrapped = described_class.wrap(fake_body, transaction)
+      wrapped.call(fake_rack_stream)
+
+      expect(transaction).to include_event(
+        "name" => "process_response_body.rack",
+        "title" => "Process Rack response body (#call)"
+      )
+    end
+
+    it "sets the exception raised inside call() into the Appsignal transaction" do
+      fake_rack_stream = double
+      allow(fake_body).to receive(:call)
+        .with(fake_rack_stream)
+        .and_raise(ExampleException, "error message")
+
+      wrapped = described_class.wrap(fake_body, transaction)
+
+      expect do
+        wrapped.call(fake_rack_stream)
+      end.to raise_error(ExampleException, "error message")
+
+      expect(transaction).to have_error("ExampleException", "error message")
+    end
+  end
+end