appsignal 4.0.6-java → 4.0.7-java

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

@@ -1,370 +0,0 @@
-describe Appsignal::Rack::AbstractMiddleware do
-  let(:app) { DummyApp.new }
-  let(:env) do
-    Rack::MockRequest.env_for(
-      "/some/path",
-      "REQUEST_METHOD" => "GET",
-      :params => { "page" => 2, "query" => "lorem" },
-      "rack.session" => { "session" => "data", "user_id" => 123 }
-    )
-  end
-  let(:middleware) { described_class.new(app, options) }
-
-  let(:appsignal_env) { :default }
-  let(:options) { {} }
-  before { start_agent(:env => appsignal_env) }
-  around { |example| keep_transactions { example.run } }
-
-  def make_request
-    middleware.call(env)
-  end
-
-  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 not active" do
-      let(:appsignal_env) { :inactive_env }
-
-      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
-        make_request
-        expect(app).to be_called
-      end
-    end
-
-    context "when appsignal is active" do
-      it "creates a transaction for the request" do
-        expect { make_request }.to(change { created_transactions.count }.by(1))
-
-        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 }
-
-        it "calls the next middleware in the stack" do
-          expect(app).to be_called
-        end
-
-        it "does not record an error" do
-          expect(last_transaction).to_not have_error
-        end
-
-        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
-          expect(last_transaction).to be_completed
-          expect(Appsignal::Transaction.current)
-            .to be_kind_of(Appsignal::Transaction::NilTransaction)
-        end
-
-        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
-          end
-        end
-      end
-
-      context "with an error" do
-        let(:error) { ExampleException.new("error message") }
-        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))
-
-          expect(last_transaction).to have_namespace(Appsignal::Transaction::HTTP_REQUEST)
-        end
-
-        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
-
-          expect(last_transaction).to_not have_action
-        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(
-            "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
-          make_request
-
-          expect(last_transaction).to include_params(
-            "page" => "2",
-            "query" => "lorem"
-          )
-        end
-
-        it "sets session data" do
-          make_request
-
-          expect(last_transaction).to include_session_data("session" => "data", "user_id" => 123)
-        end
-
-        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
-
-            expect(last_transaction).to have_queue_start(queue_start_time)
-          end
-        end
-
-        class SomeFilteredRequest
-          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(: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
-
-            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
-      end
-
-      context "with parent instrumentation" do
-        let(:transaction) { http_request_transaction }
-        before do
-          env[Appsignal::Rack::APPSIGNAL_TRANSACTION] = transaction
-          set_current_transaction(transaction)
-        end
-
-        it "uses the existing transaction" do
-          make_request
-
-          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 the response body is already instrumented" do
-          let(:body) { Appsignal::Rack::BodyWrapper.wrap(["hello!"], transaction) }
-          let(:app) { DummyApp.new { [200, {}, body] } }
-
-          it "doesn't wrap the body again" do
-            env[Appsignal::Rack::APPSIGNAL_RESPONSE_INSTRUMENTED] = true
-            _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" } }
-
-          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
-
-          expect(env[Appsignal::Rack::APPSIGNAL_TRANSACTION]).to_not be_completed
-        end
-
-        context "with custom set action name" 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
-
-            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 have_error("ExampleException", "error message")
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,319 +0,0 @@
-describe Appsignal::Rack::BodyWrapper do
-  let(:transaction) { http_request_transaction }
-  before do
-    start_agent
-    set_current_transaction(transaction)
-  end
-
-  it "forwards method calls to the body if the method doesn't exist" do
-    fake_body = double(
-      :body => ["some body"],
-      :some_method => :some_value
-    )
-
-    wrapped = described_class.wrap(fake_body, transaction)
-    expect(wrapped).to respond_to(:body)
-    expect(wrapped.body).to eq(["some body"])
-
-    expect(wrapped).to respond_to(:some_method)
-    expect(wrapped.some_method).to eq(:some_value)
-  end
-
-  it "doesn't respond to methods the Rack::BodyProxy doesn't respond to" do
-    body = Rack::BodyProxy.new(["body"])
-    wrapped = described_class.wrap(body, transaction)
-
-    expect(wrapped).to_not respond_to(:to_str)
-    expect { wrapped.to_str }.to raise_error(NoMethodError)
-
-    expect(wrapped).to_not respond_to(:body)
-    expect { wrapped.body }.to raise_error(NoMethodError)
-  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 "doesn't report EPIPE error" do
-      fake_body = double
-      expect(fake_body).to receive(:each).once.and_raise(Errno::EPIPE)
-
-      wrapped = described_class.wrap(fake_body, transaction)
-      expect do
-        expect { |b| wrapped.each(&b) }.to yield_control
-      end.to raise_error(Errno::EPIPE)
-
-      expect(transaction).to_not have_error
-    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 exposes each" do
-      fake_body = double(
-        :each => true,
-        :call => "original 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 respond_to(:call)
-      expect(wrapped.call).to eq("original 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 "doesn't report EPIPE error" do
-      expect(fake_body).to receive(:each).once.and_raise(Errno::EPIPE)
-
-      wrapped = described_class.wrap(fake_body, transaction)
-      expect do
-        expect { |b| wrapped.each(&b) }.to yield_control
-      end.to raise_error(Errno::EPIPE)
-
-      expect(transaction).to_not have_error
-    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 "doesn't report EPIPE error" do
-      expect(fake_body).to receive(:to_path).once.and_raise(Errno::EPIPE)
-
-      wrapped = described_class.wrap(fake_body, transaction)
-      expect do
-        wrapped.to_path
-      end.to raise_error(Errno::EPIPE)
-
-      expect(transaction).to_not have_error
-    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
-
-    it "doesn't report EPIPE error" do
-      fake_rack_stream = double
-      expect(fake_body).to receive(:call)
-        .with(fake_rack_stream)
-        .and_raise(Errno::EPIPE)
-
-      wrapped = described_class.wrap(fake_body, transaction)
-      expect do
-        wrapped.call(fake_rack_stream)
-      end.to raise_error(Errno::EPIPE)
-
-      expect(transaction).to_not have_error
-    end
-  end
-end