appsignal 3.9.1-java → 3.9.3-java

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

@@ -22,17 +22,19 @@ describe Appsignal::Rack::EventHandler do
     event_handler_instance.on_start(request, response)
   end
 
+  def on_error(error)
+    event_handler_instance.on_error(request, response, error)
+  end
+
   describe "#on_start" do
     it "creates a new transaction" do
       expect { on_start }.to change { created_transactions.length }.by(1)
 
       transaction = last_transaction
-      expect(transaction.to_h).to include(
-        "id" => kind_of(String),
-        "namespace" => Appsignal::Transaction::HTTP_REQUEST
-      )
+      expect(transaction).to have_id
+      expect(transaction).to have_namespace(Appsignal::Transaction::HTTP_REQUEST)
 
-      expect(Appsignal::Transaction.current).to eq(last_transaction)
+      expect(Appsignal::Transaction.current).to eq(transaction)
     end
 
     context "when the handler is nested in another EventHandler" do
@@ -66,6 +68,30 @@ describe Appsignal::Rack::EventHandler do
       expect(last_transaction.ext.queue_start).to eq(queue_start_time)
     end
 
+    context "with error inside rack.after_reply handler" do
+      before do
+        on_start
+        # A random spot we can access to raise an error for this test
+        expect(request.env[Appsignal::Rack::APPSIGNAL_TRANSACTION])
+          .to receive(:finish_event)
+          .and_raise(ExampleStandardError, "oh no")
+        callback = request.env[Appsignal::Rack::RACK_AFTER_REPLY].first
+        callback.call
+      end
+
+      it "completes the transaction" do
+        expect(last_transaction).to be_completed
+      end
+
+      it "logs an error" do
+        expect(log).to contains_log(
+          :error,
+          "Error occurred in Appsignal::Rack::EventHandler's after_reply: " \
+            "ExampleStandardError: oh no"
+        )
+      end
+    end
+
     it "logs errors from rack.after_reply callbacks" do
       on_start
 
@@ -95,21 +121,11 @@ describe Appsignal::Rack::EventHandler do
   end
 
   describe "#on_error" do
-    def on_error(error)
-      event_handler_instance.on_error(request, response, error)
-    end
-
     it "reports the error" do
       on_start
       on_error(ExampleStandardError.new("the error"))
 
-      expect(last_transaction.to_h).to include(
-        "error" => {
-          "name" => "ExampleStandardError",
-          "message" => "the error",
-          "backtrace" => kind_of(String)
-        }
-      )
+      expect(last_transaction).to have_error("ExampleStandardError", "the error")
     end
 
     context "when the handler is nested in another EventHandler" do
@@ -117,7 +133,7 @@ describe Appsignal::Rack::EventHandler do
         on_start
         described_class.new.on_error(request, response, ExampleStandardError.new("the error"))
 
-        expect(last_transaction.to_h).to include("error" => nil)
+        expect(last_transaction).to_not have_error
       end
     end
 
@@ -139,8 +155,8 @@ describe Appsignal::Rack::EventHandler do
   describe "#on_finish" do
     let(:response) { Rack::Events::BufferedResponse.new(200, {}, ["body"]) }
 
-    def on_finish
-      event_handler_instance.on_finish(request, response)
+    def on_finish(given_request = request, given_response = response)
+      event_handler_instance.on_finish(given_request, given_response)
     end
 
     it "doesn't do anything without a transaction" do
@@ -150,30 +166,92 @@ describe Appsignal::Rack::EventHandler do
 
       on_finish
 
-      expect(last_transaction.to_h).to include(
-        "action" => nil,
-        "sample_data" => {},
-        "events" => []
-      )
+      expect(last_transaction).to_not have_action
+      expect(last_transaction).to_not include_events
+      expect(last_transaction).to include("sample_data" => {})
+      expect(last_transaction).to_not be_completed
     end
 
     it "completes the transaction" do
       on_start
       on_finish
 
-      expect(last_transaction.to_h).to include(
+      expect(last_transaction).to_not have_action
+      expect(last_transaction).to include_environment(
+        "REQUEST_METHOD" => "GET",
+        "PATH_INFO" => "/path"
+      )
+      expect(last_transaction).to have_queue_start(queue_start_time)
+      expect(last_transaction).to be_completed
+    end
+
+    context "without a response" do
+      it "completes the transaction" do
+        on_start
+        on_finish(request, nil)
+
         # The action is not set on purpose, as we can't set a normalized route
         # It requires the app to set an action name
-        "action" => nil,
-        "sample_data" => hash_including(
-          "environment" => {
-            "REQUEST_METHOD" => "GET",
-            "PATH_INFO" => "/path"
-          }
+        expect(last_transaction).to_not have_action
+        expect(last_transaction).to include_environment(
+          "REQUEST_METHOD" => "GET",
+          "PATH_INFO" => "/path"
         )
-      )
-      expect(last_transaction.ext.queue_start).to eq(queue_start_time)
-      expect(last_transaction).to be_completed
+        expect(last_transaction).to have_queue_start(queue_start_time)
+        expect(last_transaction).to be_completed
+      end
+
+      it "does not set a response_status tag" do
+        on_start
+        on_finish(request, nil)
+
+        expect(last_transaction).to_not include_tags("response_status" => anything)
+      end
+
+      it "does not report a response_status counter metric" do
+        expect(Appsignal).to_not receive(:increment_counter)
+          .with(:response_status, anything, anything)
+
+        on_start
+        on_finish(request, nil)
+      end
+
+      context "with an error previously recorded by on_error" do
+        it "sets response status 500 as a tag" do
+          on_start
+          on_error(ExampleStandardError.new("the error"))
+          on_finish(request, nil)
+
+          expect(last_transaction).to include_tags("response_status" => 500)
+        end
+
+        it "increments the response status counter for response status 500" do
+          expect(Appsignal).to receive(:increment_counter)
+            .with(:response_status, 1, :status => 500, :namespace => :web)
+
+          on_start
+          on_error(ExampleStandardError.new("the error"))
+          on_finish(request, nil)
+        end
+      end
+    end
+
+    context "with error inside on_finish handler" do
+      before do
+        on_start
+        # A random spot we can access to raise an error for this test
+        expect(Appsignal).to receive(:increment_counter).and_raise(ExampleStandardError, "oh no")
+        on_finish
+      end
+
+      it "completes the transaction" do
+        expect(last_transaction).to be_completed
+      end
+
+      it "logs an error" do
+        expect(log).to contains_log(:error,
+          "Error occurred in Appsignal::Rack::EventHandler#on_finish: ExampleStandardError: oh no")
+      end
     end
 
     context "when the handler is nested in another EventHandler" do
@@ -181,12 +259,10 @@ describe Appsignal::Rack::EventHandler do
         on_start
         described_class.new.on_finish(request, response)
 
-        expect(last_transaction.to_h).to include(
-          "action" => nil,
-          "metadata" => {},
-          "sample_data" => {},
-          "events" => []
-        )
+        expect(last_transaction).to_not have_action
+        expect(last_transaction).to_not include_metadata
+        expect(last_transaction).to_not include_events
+        expect(last_transaction.to_h).to include("sample_data" => {})
         expect(last_transaction).to_not be_completed
       end
     end
@@ -196,49 +272,55 @@ describe Appsignal::Rack::EventHandler do
       last_transaction.set_action("My action")
       on_finish
 
-      expect(last_transaction.to_h).to include(
-        "action" => "My action"
-      )
+      expect(last_transaction).to have_action("My action")
     end
 
     it "finishes the process_request.rack event" do
       on_start
       on_finish
 
-      expect(last_transaction.to_h).to include(
-        "events" => [
-          hash_including(
-            "name" => "process_request.rack",
-            "title" => "",
-            "body" => "",
-            "body_format" => Appsignal::EventFormatter::DEFAULT
-          )
-        ]
-      )
+      expect(last_transaction).to include_event("name" => "process_request.rack")
     end
 
-    it "sets the response status as a tag" do
-      on_start
-      on_finish
+    context "with response" do
+      it "sets the response status as a tag" do
+        on_start
+        on_finish
 
-      expect(last_transaction.to_h).to include(
-        "sample_data" => hash_including(
-          "tags" => { "response_status" => 200 }
-        )
-      )
-    end
+        expect(last_transaction).to include_tags("response_status" => 200)
+      end
 
-    it "increments the response status counter for response status" do
-      expect(Appsignal).to receive(:increment_counter)
-        .with(:response_status, 1, :status => 200, :namespace => :web)
+      it "increments the response status counter for response status" do
+        expect(Appsignal).to receive(:increment_counter)
+          .with(:response_status, 1, :status => 200, :namespace => :web)
 
-      on_start
-      on_finish
+        on_start
+        on_finish
+      end
+
+      context "with an error previously recorded by on_error" do
+        it "sets response status from the response as a tag" do
+          on_start
+          on_error(ExampleStandardError.new("the error"))
+          on_finish
+
+          expect(last_transaction).to include_tags("response_status" => 200)
+        end
+
+        it "increments the response status counter based on the response" do
+          expect(Appsignal).to receive(:increment_counter)
+            .with(:response_status, 1, :status => 200, :namespace => :web)
+
+          on_start
+          on_error(ExampleStandardError.new("the error"))
+          on_finish
+        end
+      end
     end
 
     it "logs an error in case of an error" do
-      expect(Appsignal::Transaction)
-        .to receive(:complete_current!).and_raise(ExampleStandardError, "oh no")
+      # A random spot we can access to raise an error for this test
+      expect(Appsignal).to receive(:increment_counter).and_raise(ExampleStandardError, "oh no")
 
       on_start
       on_finish

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

@@ -14,17 +14,7 @@ describe Appsignal::Rack::GenericInstrumentation do
     it "reports a process_action.generic 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.generic",
-            "title" => ""
-          )
-        ]
-      )
+      expect(last_transaction).to include_event("name" => "process_action.generic")
     end
   end
 
@@ -32,7 +22,7 @@ describe Appsignal::Rack::GenericInstrumentation do
     it "reports 'unknown' as the action name" do
       make_request(env)
 
-      expect(last_transaction.to_h).to include("action" => "unknown")
+      expect(last_transaction).to have_action("unknown")
     end
   end
 end

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 Probes constant calling the Minutely 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

@@ -0,0 +1,36 @@
+require "appsignal/rack/hanami_middleware"
+
+if DependencyHelper.hanami2_present?
+  describe Appsignal::Rack::HanamiMiddleware do
+    let(:app) { double(:call => true) }
+    let(:router_params) { { "param1" => "value1", "param2" => "value2" } }
+    let(:env) do
+      Rack::MockRequest.env_for(
+        "/some/path",
+        "router.params" => router_params
+      )
+    end
+    let(:middleware) { Appsignal::Rack::HanamiMiddleware.new(app, {}) }
+
+    before(:context) { start_agent }
+    around { |example| keep_transactions { example.run } }
+
+    def make_request(env)
+      middleware.call(env)
+    end
+
+    context "with params" do
+      it "sets request parameters on the transaction" do
+        make_request(env)
+
+        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 include_event("name" => "process_action.hanami")
+    end
+  end
+end