appsignal 2.5.0.alpha.1-java

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

@@ -0,0 +1,147 @@
+describe Appsignal::Rack::JSExceptionCatcher do
+  let(:app)            { double(:call => true) }
+  let(:options)        { nil }
+  let(:config_options) { { :enable_frontend_error_catching => true } }
+  let(:config)         { project_fixture_config("production", config_options) }
+  before { Appsignal.config = config }
+
+  describe "#initialize" do
+    it "logs to the logger" do
+      expect(Appsignal.logger).to receive(:debug)
+        .with("Initializing Appsignal::Rack::JSExceptionCatcher")
+
+      Appsignal::Rack::JSExceptionCatcher.new(app, options)
+    end
+  end
+
+  describe "#call" do
+    let(:catcher) { Appsignal::Rack::JSExceptionCatcher.new(app, options) }
+    after { catcher.call(env) }
+
+    context "when path is not frontend_error_catching_path" do
+      let(:env) { { "PATH_INFO" => "/foo" } }
+
+      context "when AppSignal is not active" do
+        before { config[:active] = false }
+
+        it "calls the next middleware" do
+          expect(app).to receive(:call).with(env)
+        end
+      end
+
+      context "when AppSignal is active" do
+        before { config[:active] = true }
+
+        it "calls the next middleware" do
+          expect(app).to receive(:call).with(env)
+        end
+      end
+    end
+
+    context "when path is frontend_error_catching_path" do
+      let(:transaction) { double(:complete! => true) }
+      let(:env) do
+        {
+          "PATH_INFO"  => "/appsignal_error_catcher",
+          "rack.input" => double(:read => '{"name": "error"}')
+        }
+      end
+
+      context "when AppSignal is not active" do
+        before { config[:active] = false }
+
+        it "doesn't create an AppSignal transaction" do
+          expect(Appsignal::JSExceptionTransaction).to_not receive(:new)
+        end
+
+        it "returns a 202 status" do
+          expect(catcher.call(env)).to eq(
+            [202, {}, ["AppSignal JavaScript error catching endpoint is not active."]]
+          )
+        end
+      end
+
+      context "when AppSignal is active" do
+        before { config[:active] = true }
+
+        it "creates a JSExceptionTransaction" do
+          expect(Appsignal::JSExceptionTransaction).to receive(:new)
+            .with("name" => "error")
+            .and_return(transaction)
+
+          expect(transaction).to receive(:complete!)
+        end
+
+        it "returns 200" do
+          allow(Appsignal::JSExceptionTransaction).to receive(:new)
+            .and_return(transaction)
+
+          expect(catcher.call(env)).to eq([200, {}, []])
+        end
+
+        context "when request payload is empty" do
+          let(:env) do
+            {
+              "PATH_INFO"  => "/appsignal_error_catcher",
+              "rack.input" => double(:read => "")
+            }
+          end
+
+          it "does not create a transaction" do
+            expect(Appsignal::JSExceptionTransaction).to_not receive(:new)
+          end
+
+          it "returns 400" do
+            expect(catcher.call(env)).to eq([400, {}, ["Request payload is not valid JSON."]])
+          end
+        end
+
+        context "when `frontend_error_catching_path` is different" do
+          let(:config_options) { { :frontend_error_catching_path => "/foo" } }
+
+          it "does not create a transaction" do
+            expect(Appsignal::JSExceptionTransaction).to_not receive(:new)
+          end
+
+          it "calls the next middleware" do
+            expect(app).to receive(:call).with(env)
+          end
+        end
+
+        context "when `name` is empty" do
+          let(:env) do
+            {
+              "PATH_INFO"  => "/appsignal_error_catcher",
+              "rack.input" => double(:read => '{"name": ""}')
+            }
+          end
+
+          it "does not create a transaction" do
+            expect(Appsignal::JSExceptionTransaction).to_not receive(:new)
+          end
+
+          it "returns 422" do
+            expect(catcher.call(env)).to eq([422, {}, []])
+          end
+        end
+
+        context "when `name` doesn't exist" do
+          let(:env) do
+            {
+              "PATH_INFO"  => "/appsignal_error_catcher",
+              "rack.input" => double(:read => '{"foo": ""}')
+            }
+          end
+
+          it "does not create a transaction" do
+            expect(Appsignal::JSExceptionTransaction).to_not receive(:new)
+          end
+
+          it "returns 422" do
+            expect(catcher.call(env)).to eq([422, {}, []])
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,117 @@
+if DependencyHelper.rails_present?
+  class MockController
+  end
+
+  describe Appsignal::Rack::RailsInstrumentation do
+    before :context do
+      start_agent
+    end
+
+    let(:app) { double(:call => true) }
+    let(:env) do
+      http_request_env_with_data("action_dispatch.request_id" => "1").tap do |request|
+        request["action_controller.instance"] = double(
+          :class => MockController,
+          :action_name => "index"
+        )
+      end
+    end
+    let(:middleware) { Appsignal::Rack::RailsInstrumentation.new(app, {}) }
+
+    describe "#call" do
+      before do
+        allow(middleware).to receive(:raw_payload).and_return({})
+      end
+
+      context "when appsignal is active" do
+        before { allow(Appsignal).to receive(:active?).and_return(true) }
+
+        it "should call with monitoring" do
+          expect(middleware).to receive(:call_with_appsignal_monitoring).with(env)
+        end
+      end
+
+      context "when appsignal is not active" do
+        before { allow(Appsignal).to receive(:active?).and_return(false) }
+
+        it "should not call with monitoring" do
+          expect(middleware).to_not receive(:call_with_appsignal_monitoring)
+        end
+
+        it "should call the app" do
+          expect(app).to receive(:call).with(env)
+        end
+      end
+
+      after { middleware.call(env) }
+    end
+
+    describe "#call_with_appsignal_monitoring", :error => false do
+      it "should create a transaction" do
+        expect(Appsignal::Transaction).to receive(:create).with(
+          "1",
+          Appsignal::Transaction::HTTP_REQUEST,
+          kind_of(ActionDispatch::Request),
+          :params_method => :filtered_parameters
+        ).and_return(
+          instance_double(
+            "Appsignal::Transaction",
+            :set_action => nil,
+            :set_action_if_nil => nil,
+            :set_http_or_background_queue_start => nil,
+            :set_metadata => nil
+          )
+        )
+      end
+
+      it "should call the app" do
+        expect(app).to receive(:call).with(env)
+      end
+
+      context "with an exception", :error => true do
+        let(:error) { ExampleException }
+        let(:app) do
+          double.tap do |d|
+            allow(d).to receive(:call).and_raise(error)
+          end
+        end
+
+        it "records the exception" do
+          expect_any_instance_of(Appsignal::Transaction).to receive(:set_error).with(error)
+        end
+      end
+
+      it "should set metadata" do
+        expect_any_instance_of(Appsignal::Transaction).to receive(:set_metadata).twice
+      end
+
+      it "should set the action and queue start" do
+        expect_any_instance_of(Appsignal::Transaction).to receive(:set_action_if_nil).with("MockController#index")
+        expect_any_instance_of(Appsignal::Transaction).to receive(:set_http_or_background_queue_start)
+      end
+
+      after(:error => false) { middleware.call(env) }
+      after(:error => true) { expect { middleware.call(env) }.to raise_error(error) }
+    end
+
+    describe "#request_id" do
+      subject { middleware.request_id(env) }
+
+      context "with request id present" do
+        let(:env) { { "action_dispatch.request_id" => "id" } }
+
+        it "returns the present id" do
+          is_expected.to eq "id"
+        end
+      end
+
+      context "with request id not present" do
+        let(:env) { {} }
+
+        it "sets a new id" do
+          expect(subject.length).to eq 36
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,213 @@
+if DependencyHelper.sinatra_present?
+  require "appsignal/integrations/sinatra"
+
+  describe Appsignal::Rack::SinatraInstrumentation do
+    let(:settings) { double(:raise_errors => false) }
+    let(:app) { double(:call => true, :settings => settings) }
+    let(:env) { { "sinatra.route" => "GET /", :path => "/", :method => "GET" } }
+    let(:middleware) { Appsignal::Rack::SinatraInstrumentation.new(app) }
+
+    describe "#call" do
+      before do
+        start_agent
+        allow(middleware).to receive(:raw_payload).and_return({})
+        allow(Appsignal).to receive(:active?).and_return(true)
+      end
+
+      it "should call without monitoring" do
+        expect(Appsignal::Transaction).to_not receive(:create)
+      end
+
+      after { middleware.call(env) }
+    end
+
+    describe ".settings" do
+      subject { middleware.settings }
+
+      it "should return the app's settings" do
+        expect(subject).to eq(app.settings)
+      end
+    end
+  end
+
+  describe Appsignal::Rack::SinatraBaseInstrumentation do
+    before :context do
+      start_agent
+    end
+
+    let(:settings) { double(:raise_errors => false) }
+    let(:app) { double(:call => true, :settings => settings) }
+    let(:env) { { "sinatra.route" => "GET /", :path => "/", :method => "GET" } }
+    let(:options) { {} }
+    let(:middleware) { Appsignal::Rack::SinatraBaseInstrumentation.new(app, options) }
+
+    describe "#initialize" do
+      context "with no settings method in the Sinatra app" do
+        let(:app) { double(:call => true) }
+
+        it "should not raise errors" do
+          expect(middleware.raise_errors_on).to be(false)
+        end
+      end
+
+      context "with no raise_errors setting in the Sinatra app" do
+        let(:app) { double(:call => true, :settings => double) }
+
+        it "should not raise errors" do
+          expect(middleware.raise_errors_on).to be(false)
+        end
+      end
+
+      context "with raise_errors turned off in the Sinatra app" do
+        let(:app) { double(:call => true, :settings => double(:raise_errors => false)) }
+
+        it "should raise errors" do
+          expect(middleware.raise_errors_on).to be(false)
+        end
+      end
+
+      context "with raise_errors turned on in the Sinatra app" do
+        let(:app) { double(:call => true, :settings => double(:raise_errors => true)) }
+
+        it "should raise errors" do
+          expect(middleware.raise_errors_on).to be(true)
+        end
+      end
+    end
+
+    describe "#call" do
+      before do
+        allow(middleware).to receive(:raw_payload).and_return({})
+      end
+
+      context "when appsignal is active" do
+        before { allow(Appsignal).to receive(:active?).and_return(true) }
+
+        it "should call with monitoring" do
+          expect(middleware).to receive(:call_with_appsignal_monitoring).with(env)
+        end
+      end
+
+      context "when appsignal is not active" do
+        before { allow(Appsignal).to receive(:active?).and_return(false) }
+
+        it "should not call with monitoring" do
+          expect(middleware).to_not receive(:call_with_appsignal_monitoring)
+        end
+
+        it "should call the stack" do
+          expect(app).to receive(:call).with(env)
+        end
+      end
+
+      after { middleware.call(env) }
+    end
+
+    describe "#call_with_appsignal_monitoring", :error => false do
+      it "should create a transaction" do
+        expect(Appsignal::Transaction).to receive(:create).with(
+          kind_of(String),
+          Appsignal::Transaction::HTTP_REQUEST,
+          kind_of(Sinatra::Request),
+          kind_of(Hash)
+        ).and_return(double(:set_action_if_nil => nil, :set_http_or_background_queue_start => nil, :set_metadata => nil))
+      end
+
+      it "should call the app" do
+        expect(app).to receive(:call).with(env)
+      end
+
+      context "with an error", :error => true do
+        let(:error) { ExampleException }
+        let(:app) do
+          double.tap do |d|
+            allow(d).to receive(:call).and_raise(error)
+            allow(d).to receive(:settings).and_return(settings)
+          end
+        end
+
+        it "records the exception" do
+          expect_any_instance_of(Appsignal::Transaction).to receive(:set_error).with(error)
+        end
+      end
+
+      context "with an error in sinatra.error" do
+        let(:error) { ExampleException }
+        let(:env) { { "sinatra.error" => error } }
+
+        it "records the exception" do
+          expect_any_instance_of(Appsignal::Transaction).to receive(:set_error).with(error)
+        end
+
+        context "when raise_errors is on" do
+          let(:settings) { double(:raise_errors => true) }
+
+          it "does not record the error" do
+            expect_any_instance_of(Appsignal::Transaction).to_not receive(:set_error)
+          end
+        end
+
+        context "if sinatra.skip_appsignal_error is set" do
+          let(:env) { { "sinatra.error" => error, "sinatra.skip_appsignal_error" => true } }
+
+          it "does not record the error" do
+            expect_any_instance_of(Appsignal::Transaction).to_not receive(:set_error)
+          end
+        end
+      end
+
+      describe "action name" do
+        it "should set the action" do
+          expect_any_instance_of(Appsignal::Transaction).to receive(:set_action_if_nil).with("GET /")
+        end
+
+        context "without 'sinatra.route' env" do
+          let(:env) { { :path => "/", :method => "GET" } }
+
+          it "returns nil" do
+            expect_any_instance_of(Appsignal::Transaction).to receive(:set_action_if_nil).with(nil)
+          end
+        end
+
+        context "with mounted modular application" do
+          before { env["SCRIPT_NAME"] = "/api" }
+
+          it "should call set_action with an application prefix path" do
+            expect_any_instance_of(Appsignal::Transaction).to receive(:set_action_if_nil).with("GET /api/")
+          end
+
+          context "without 'sinatra.route' env" do
+            let(:env) { { :path => "/", :method => "GET" } }
+
+            it "returns nil" do
+              expect_any_instance_of(Appsignal::Transaction).to receive(:set_action_if_nil).with(nil)
+            end
+          end
+        end
+      end
+
+      it "should set metadata" do
+        expect_any_instance_of(Appsignal::Transaction).to receive(:set_metadata).twice
+      end
+
+      it "should set the queue start" do
+        expect_any_instance_of(Appsignal::Transaction).to receive(:set_http_or_background_queue_start)
+      end
+
+      context "with overridden request class and params method" do
+        let(:options) { { :request_class => ::Rack::Request, :params_method => :filtered_params } }
+
+        it "should use the overridden request class and params method" do
+          request = ::Rack::Request.new(env)
+          expect(::Rack::Request).to receive(:new)
+            .with(env.merge(:params_method => :filtered_params))
+            .at_least(:once)
+            .and_return(request)
+        end
+      end
+
+      after(:error => false) { middleware.call(env) }
+      after(:error => true) { expect { middleware.call(env) }.to raise_error(error) }
+    end
+  end
+end