appsignal 3.9.2-java → 3.10.0-java

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

@@ -0,0 +1,234 @@
+if DependencyHelper.grape_present?
+  require "appsignal/integrations/grape"
+
+  context "Appsignal::Grape::Middleware constant" do
+    let(:err_stream) { std_stream }
+    let(:stderr) { err_stream.read }
+
+    it "returns the Rack::GrapeMiddleware constant calling the Grape::Middleware constant" do
+      silence { expect(Appsignal::Grape::Middleware).to be(Appsignal::Rack::GrapeMiddleware) }
+    end
+
+    it "prints a deprecation warning to STDERR" do
+      capture_std_streams(std_stream, err_stream) do
+        expect(Appsignal::Grape::Middleware).to be(Appsignal::Rack::GrapeMiddleware)
+      end
+
+      expect(stderr).to include(
+        "appsignal WARNING: The constant Appsignal::Grape::Middleware has been deprecated."
+      )
+    end
+
+    it "logs a warning" do
+      logs =
+        capture_logs do
+          silence do
+            expect(Appsignal::Grape::Middleware).to be(Appsignal::Rack::GrapeMiddleware)
+          end
+        end
+
+      expect(logs).to contains_log(
+        :warn,
+        "The constant Appsignal::Grape::Middleware has been deprecated."
+      )
+    end
+  end
+
+  describe Appsignal::Rack::GrapeMiddleware do
+    let(:app) do
+      Class.new(::Grape::API) do
+        format :json
+        post :ping do
+          { :message => "Hello world!" }
+        end
+      end
+    end
+    let(:api_endpoint) { app.endpoints.first }
+    let(:env) do
+      http_request_env_with_data \
+        "api.endpoint" => api_endpoint,
+        "REQUEST_METHOD" => "POST",
+        :path => "/ping"
+    end
+    let(:middleware) { Appsignal::Rack::GrapeMiddleware.new(api_endpoint) }
+    let(:transaction) { http_request_transaction }
+    before(:context) { start_agent }
+    around do |example|
+      GrapeExample = Module.new
+      GrapeExample.send(:const_set, :Api, app)
+      keep_transactions { example.run }
+      Object.send(:remove_const, :GrapeExample)
+    end
+
+    def make_request(env)
+      middleware.call(env)
+    end
+
+    def make_request_with_exception(env, exception_class, exception_message)
+      expect do
+        middleware.call(env)
+      end.to raise_error(exception_class, exception_message)
+    end
+
+    context "with error" do
+      let(:app) do
+        Class.new(::Grape::API) do
+          format :json
+          post :ping do
+            raise ExampleException, "error message"
+          end
+        end
+      end
+
+      it "sets the error" do
+        make_request_with_exception(env, ExampleException, "error message")
+
+        expect(last_transaction).to have_error("ExampleException", "error message")
+      end
+
+      context "with env['grape.skip_appsignal_error'] = true" do
+        let(:app) do
+          Class.new(::Grape::API) do
+            format :json
+            post :ping do
+              env["grape.skip_appsignal_error"] = true
+              raise ExampleException, "error message"
+            end
+          end
+        end
+
+        it "does not add the error" do
+          make_request_with_exception(env, ExampleException, "error message")
+
+          expect(last_transaction).to_not have_error
+        end
+      end
+    end
+
+    context "with route" do
+      let(:app) do
+        Class.new(::Grape::API) do
+          route([:get, :post], "hello") do
+            "Hello!"
+          end
+        end
+      end
+      let(:env) do
+        http_request_env_with_data \
+          "api.endpoint" => api_endpoint,
+          "REQUEST_METHOD" => "GET",
+          :path => ""
+      end
+
+      it "sets non-unique route path" do
+        make_request(env)
+
+        expect(last_transaction).to have_action("GET::GrapeExample::Api#/hello")
+        expect(last_transaction).to include_metadata("path" => "/hello", "method" => "GET")
+      end
+    end
+
+    context "with route_param" do
+      let(:app) do
+        Class.new(::Grape::API) do
+          format :json
+          resource :users do
+            route_param :id do
+              get do
+                { :name => "Tom" }
+              end
+            end
+          end
+        end
+      end
+      let(:env) do
+        http_request_env_with_data \
+          "api.endpoint" => api_endpoint,
+          "REQUEST_METHOD" => "GET",
+          :path => ""
+      end
+
+      it "sets non-unique route_param path" do
+        make_request(env)
+
+        expect(last_transaction).to have_action("GET::GrapeExample::Api#/users/:id/")
+        expect(last_transaction).to include_metadata("path" => "/users/:id/", "method" => "GET")
+      end
+    end
+
+    context "with namespaced path" do
+      context "with symbols" do
+        let(:app) do
+          Class.new(::Grape::API) do
+            format :json
+            namespace :v1 do
+              namespace :beta do
+                post :ping do
+                  { :message => "Hello namespaced world!" }
+                end
+              end
+            end
+          end
+        end
+
+        it "sets namespaced path" do
+          make_request(env)
+
+          expect(last_transaction).to have_action("POST::GrapeExample::Api#/v1/beta/ping")
+          expect(last_transaction).to include_metadata("path" => "/v1/beta/ping",
+            "method" => "POST")
+        end
+      end
+
+      context "with strings" do
+        context "without / prefix" do
+          let(:app) do
+            Class.new(::Grape::API) do
+              format :json
+              namespace "v1" do
+                namespace "beta" do
+                  post "ping" do
+                    { :message => "Hello namespaced world!" }
+                  end
+                end
+              end
+            end
+          end
+
+          it "sets namespaced path" do
+            make_request(env)
+
+            expect(last_transaction).to have_action("POST::GrapeExample::Api#/v1/beta/ping")
+            expect(last_transaction).to include_metadata(
+              "path" => "/v1/beta/ping",
+              "method" => "POST"
+            )
+          end
+        end
+
+        context "with / prefix" do
+          let(:app) do
+            Class.new(::Grape::API) do
+              format :json
+              namespace "/v1" do
+                namespace "/beta" do
+                  post "/ping" do
+                    { :message => "Hello namespaced world!" }
+                  end
+                end
+              end
+            end
+          end
+
+          it "sets namespaced path" do
+            make_request(env)
+
+            expect(last_transaction).to have_action("POST::GrapeExample::Api#/v1/beta/ping")
+            expect(last_transaction).to include_metadata("path" => "/v1/beta/ping",
+              "method" => "POST")
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -23,28 +23,14 @@ if DependencyHelper.hanami2_present?
       it "sets request parameters on the transaction" do
         make_request(env)
 
-        expect(last_transaction.to_h).to include(
-          "sample_data" => hash_including(
-            "params" => { "param1" => "value1", "param2" => "value2" }
-          )
-        )
+        expect(last_transaction).to include_params("param1" => "value1", "param2" => "value2")
       end
     end
 
     it "reports a process_action.hanami event" do
       make_request(env)
 
-      expect(last_transaction.to_h).to include(
-        "events" => [
-          hash_including(
-            "body" => "",
-            "body_format" => Appsignal::EventFormatter::DEFAULT,
-            "count" => 1,
-            "name" => "process_action.hanami",
-            "title" => ""
-          )
-        ]
-      )
+      expect(last_transaction).to include_event("name" => "process_action.hanami")
     end
   end
 end

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

@@ -0,0 +1,38 @@
+describe Appsignal::Rack::InstrumentationMiddleware do
+  let(:app) { DummyApp.new }
+  let(:env) { Rack::MockRequest.env_for("/some/path") }
+  let(:middleware) { described_class.new(app, {}) }
+
+  before { start_agent }
+  around { |example| keep_transactions { example.run } }
+
+  def make_request(env)
+    middleware.call(env)
+  end
+
+  context "without an exception" do
+    it "reports a process_request_middleware.rack event" do
+      make_request(env)
+
+      expect(last_transaction).to include_event("name" => "process_request_middleware.rack")
+    end
+  end
+
+  context "with custom action name" do
+    let(:app) { DummyApp.new { |_env| Appsignal.set_action("MyAction") } }
+
+    it "reports the custom action name" do
+      make_request(env)
+
+      expect(last_transaction).to have_action("MyAction")
+    end
+  end
+
+  context "without action name metadata" do
+    it "reports no action name" do
+      make_request(env)
+
+      expect(last_transaction).to_not have_action
+    end
+  end
+end

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

@@ -3,11 +3,6 @@ if DependencyHelper.rails_present?
     class MockController; end
 
     let(:log) { StringIO.new }
-    before do
-      start_agent
-      Appsignal.internal_logger = test_logger(log)
-    end
-
     let(:transaction) do
       Appsignal::Transaction.new(
         "transaction_id",
@@ -15,7 +10,7 @@ if DependencyHelper.rails_present?
         Rack::Request.new(env)
       )
     end
-    let(:app) { double(:call => true) }
+    let(:app) { DummyApp.new }
     let(:params) do
       {
         "controller" => "blog_posts",
@@ -25,9 +20,8 @@ if DependencyHelper.rails_present?
         "password" => "super secret"
       }
     end
-    let(:env_extra) { {} }
     let(:env) do
-      http_request_env_with_data({
+      http_request_env_with_data(
         :params => params,
         :with_queue_start => true,
         "action_dispatch.request_id" => "request_id123",
@@ -36,160 +30,102 @@ if DependencyHelper.rails_present?
           :class => MockController,
           :action_name => "index"
         )
-      }.merge(env_extra))
+      )
     end
     let(:middleware) { Appsignal::Rack::RailsInstrumentation.new(app, {}) }
     around { |example| keep_transactions { example.run } }
     before do
+      start_agent
+      Appsignal.internal_logger = test_logger(log)
       env[Appsignal::Rack::APPSIGNAL_TRANSACTION] = transaction
     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 "calls with monitoring" do
-          expect(middleware).to receive(:call_with_appsignal_monitoring).with(env)
-        end
-      end
+    def make_request
+      middleware.call(env)
+      last_transaction&._sample
+    end
 
-      context "when appsignal is not active" do
-        before { allow(Appsignal).to receive(:active?).and_return(false) }
+    def make_request_with_error(error_class, error_message)
+      expect { make_request }.to raise_error(error_class, error_message)
+    end
 
-        it "does not call with monitoring" do
-          expect(middleware).to_not receive(:call_with_appsignal_monitoring)
-        end
+    context "with a request that doesn't raise an error" do
+      before { make_request }
 
-        it "calls the app" do
-          expect(app).to receive(:call).with(env)
-        end
+      it "calls the next middleware in the stack" do
+        expect(app).to be_called
       end
 
-      after { middleware.call(env) }
+      it "does not instrument an event" do
+        expect(last_transaction).to_not include_events
+      end
     end
 
-    describe "#call_with_appsignal_monitoring" do
-      def run
-        middleware.call(env)
-        last_transaction.complete # Manually close transaction to set sample data
+    context "with a request that raises an error" do
+      let(:app) do
+        DummyApp.new { |_env| raise ExampleException, "error message" }
+      end
+      before do
+        make_request_with_error(ExampleException, "error message")
       end
 
-      it "calls the wrapped app" do
-        expect { run }.to_not(change { created_transactions.length })
-        expect(app).to have_received(:call).with(env)
+      it "calls the next middleware in the stack" do
+        expect(app).to be_called
       end
 
-      it "sets request metadata on the transaction" do
-        run
-
-        expect(last_transaction.to_h).to include(
-          "namespace" => Appsignal::Transaction::HTTP_REQUEST,
-          "action" => "MockController#index",
-          "metadata" => hash_including(
-            "method" => "GET",
-            "path" => "/blog"
-          ),
-          "sample_data" => hash_including(
-            "tags" => { "request_id" => "request_id123" }
-          )
-        )
+      it "reports the error on the transaction" do
+        expect(last_transaction).to have_error("ExampleException", "error message")
       end
+    end
 
-      it "reports Rails filter parameters" do
-        run
+    it "sets the controller action as the action name" do
+      make_request
 
-        expect(last_transaction.to_h).to include(
-          "sample_data" => hash_including(
-            "params" => params.merge(
-              "my_custom_param" => "[FILTERED]",
-              "password" => "[FILTERED]"
-            )
-          )
-        )
-      end
+      expect(last_transaction).to have_namespace(Appsignal::Transaction::HTTP_REQUEST)
+      expect(last_transaction).to have_action("MockController#index")
+    end
 
-      context "with custom params" do
-        let(:app) do
-          lambda do |env|
-            env[Appsignal::Rack::APPSIGNAL_TRANSACTION].set_params("custom_param" => "yes")
-          end
-        end
-
-        it "allows custom params to be set" do
-          run
-
-          expect(last_transaction.to_h).to include(
-            "sample_data" => hash_including(
-              "params" => {
-                "custom_param" => "yes"
-              }
-            )
-          )
-        end
-      end
+    it "sets request metadata on the transaction" do
+      make_request
 
-      context "with an invalid HTTP request method" do
-        let(:env_extra) { { :request_method => "FOO", "REQUEST_METHOD" => "FOO" } }
+      expect(last_transaction).to include_metadata(
+        "method" => "GET",
+        "path" => "/blog"
+      )
+      expect(last_transaction).to include_tags("request_id" => "request_id123")
+    end
 
-        it "does not store the HTTP request method" do
-          run
+    it "reports Rails filter parameters" do
+      make_request
 
-          transaction_hash = last_transaction.to_h
-          expect(transaction_hash["metadata"]).to_not have_key("method")
-          expect(log_contents(log))
-            .to contains_log(:error, "Unable to report HTTP request method: '")
-        end
-      end
+      expect(last_transaction).to include_params(
+        "controller" => "blog_posts",
+        "action" => "show",
+        "id" => "1",
+        "my_custom_param" => "[FILTERED]",
+        "password" => "[FILTERED]"
+      )
+    end
 
-      context "with an exception" do
-        let(:error) { ExampleException.new("ExampleException message") }
-        let(:app) do
-          double.tap do |d|
-            allow(d).to receive(:call).and_raise(error)
-          end
-        end
-
-        it "records the exception" do
-          expect { run }.to raise_error(error)
-
-          transaction_hash = last_transaction.to_h
-          expect(transaction_hash["error"]).to include(
-            "name" => "ExampleException",
-            "message" => "ExampleException message",
-            "backtrace" => kind_of(String)
-          )
-        end
-      end
+    context "with an invalid HTTP request method" do
+      it "does not store the invalid HTTP request method" do
+        env[:request_method] = "FOO"
+        env["REQUEST_METHOD"] = "FOO"
+        make_request
 
-      context "with a request path that's not a route" do
-        let(:env_extra) do
-          {
-            :path => "/unknown-route",
-            "action_controller.instance" => nil
-          }
-        end
-
-        it "doesn't set an action name" do
-          run
-
-          expect(last_transaction.to_h).to include(
-            "action" => nil
-          )
-        end
+        expect(last_transaction).to_not include_metadata("method" => anything)
+        expect(log_contents(log))
+          .to contains_log(:error, "Unable to report HTTP request method: '")
       end
     end
 
-    describe "#fetch_request_id" do
-      subject { middleware.fetch_request_id(env) }
-
-      let(:env) { { "action_dispatch.request_id" => "id" } }
+    context "with a request path that's not a route" do
+      it "doesn't set an action name" do
+        env[:path] = "/unknown-route"
+        env["action_controller.instance"] = nil
+        make_request
 
-      it "returns the action dispatch id" do
-        is_expected.to eq "id"
+        expect(last_transaction).to_not have_action
       end
     end
   end