appsignal 3.9.2-java → 3.10.0-java

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

@@ -2,11 +2,11 @@ if DependencyHelper.sinatra_present?
   require "appsignal/integrations/sinatra"
 
   module SinatraRequestHelpers
-    def make_request(env)
+    def make_request
       middleware.call(env)
     end
 
-    def make_request_with_error(env, error)
+    def make_request_with_error(error)
       expect { middleware.call(env) }.to raise_error(error)
     end
   end
@@ -30,7 +30,7 @@ if DependencyHelper.sinatra_present?
       before { allow(middleware).to receive(:raw_payload).and_return({}) }
 
       it "doesn't instrument requests" do
-        expect { make_request(env) }.to_not(change { created_transactions.count })
+        expect { make_request }.to_not(change { created_transactions.count })
       end
     end
 
@@ -100,54 +100,48 @@ if DependencyHelper.sinatra_present?
         before { allow(Appsignal).to receive(:active?).and_return(false) }
 
         it "does not instrument requests" do
-          expect { make_request(env) }.to_not(change { created_transactions.count })
+          expect { make_request }.to_not(change { created_transactions.count })
         end
 
         it "calls the next middleware in the stack" do
-          make_request(env)
+          make_request
 
           expect(app).to have_received(:call).with(env)
         end
       end
 
       context "when appsignal is active" do
-        context "without an exception" do
+        context "without an error" 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 "reports a process_action.sinatra 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.sinatra",
-                  "title" => ""
-                )
-              ]
-            )
+            make_request
+
+            expect(last_transaction).to include_event("name" => "process_action.sinatra")
           end
         end
 
         context "with an error in sinatra.error" do
           let(:error) { ExampleException.new("error message") }
-          before do
-            env["sinatra.error"] = error
+          before { env["sinatra.error"] = error }
+
+          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
 
           context "when raise_errors is off" do
             let(:settings) { double(:raise_errors => false) }
 
-            it "record the error" do
-              expect { make_request(env) }
-                .to(change { created_transactions.count }.by(1))
+            it "records the error" do
+              make_request
 
-              expect(last_transaction.to_h).to include(
-                "error" => hash_including(
-                  "name" => "ExampleException",
-                  "message" => "error message"
-                )
-              )
+              expect(last_transaction).to have_error("ExampleException", "error message")
             end
           end
 
@@ -155,10 +149,9 @@ if DependencyHelper.sinatra_present?
             let(:settings) { double(:raise_errors => true) }
 
             it "does not record the error" do
-              expect { make_request(env) }
-                .to(change { created_transactions.count }.by(1))
+              make_request
 
-              expect(last_transaction.to_h).to include("error" => nil)
+              expect(last_transaction).to_not have_error
             end
           end
 
@@ -171,19 +164,18 @@ if DependencyHelper.sinatra_present?
             end
 
             it "does not record the error" do
-              expect { make_request(env) }
-                .to(change { created_transactions.count }.by(1))
+              make_request
 
-              expect(last_transaction.to_h).to include("error" => nil)
+              expect(last_transaction).to_not have_error
             end
           end
         end
 
         describe "action name" do
           it "sets the action to the request method and path" do
-            make_request(env)
+            make_request
 
-            expect(last_transaction.to_h).to include("action" => "GET /path")
+            expect(last_transaction).to have_action("GET /path")
           end
 
           context "without 'sinatra.route' env" do
@@ -192,9 +184,9 @@ if DependencyHelper.sinatra_present?
             end
 
             it "doesn't set an action name" do
-              make_request(env)
+              make_request
 
-              expect(last_transaction.to_h).to include("action" => nil)
+              expect(last_transaction).to_not have_action
             end
           end
 
@@ -202,9 +194,9 @@ if DependencyHelper.sinatra_present?
             before { env["SCRIPT_NAME"] = "/api" }
 
             it "sets the action name with an application prefix path" do
-              make_request(env)
+              make_request
 
-              expect(last_transaction.to_h).to include("action" => "GET /api/path")
+              expect(last_transaction).to have_action("GET /api/path")
             end
 
             context "without 'sinatra.route' env" do
@@ -213,9 +205,9 @@ if DependencyHelper.sinatra_present?
               end
 
               it "doesn't set an action name" do
-                make_request(env)
+                make_request
 
-                expect(last_transaction.to_h).to include("action" => nil)
+                expect(last_transaction).to_not have_action
               end
             end
           end

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

@@ -1,164 +1,69 @@
-require "appsignal/rack/streaming_listener"
-
-describe Appsignal::Rack::StreamingListener do
-  before(:context) { start_agent }
-  let(:headers) { {} }
-  let(:env) do
-    {
-      "rack.input" => StringIO.new,
-      "REQUEST_METHOD" => "GET",
-      "PATH_INFO" => "/homepage",
-      "QUERY_STRING" => "param=something"
-    }
+describe "Appsignal::Rack::StreamingListener" do
+  def load_middleware
+    load "lib/appsignal/rack/streaming_listener.rb"
   end
-  let(:app)      { double(:call => [200, headers, "body"]) }
-  let(:listener) { Appsignal::Rack::StreamingListener.new(app, {}) }
-
-  describe "#call" do
-    context "when Appsignal is active" do
-      before { allow(Appsignal).to receive(:active?).and_return(true) }
-
-      it "should call `call_with_appsignal_monitoring`" do
-        expect(listener).to receive(:call_with_appsignal_monitoring)
-      end
-    end
 
-    context "when Appsignal is not active" do
-      before { allow(Appsignal).to receive(:active?).and_return(false) }
+  describe "loading the streaming_listener integrations file" do
+    let(:err_stream) { std_stream }
+    let(:stderr) { err_stream.read }
+    after { Appsignal::Rack.send(:remove_const, :StreamingListener) }
 
-      it "should not call `call_with_appsignal_monitoring`" do
-        expect(listener).to_not receive(:call_with_appsignal_monitoring)
+    it "prints a deprecation warning to STDERR" do
+      capture_std_streams(std_stream, err_stream) do
+        load_middleware
       end
-    end
 
-    after { listener.call(env) }
-  end
-
-  describe "#call_with_appsignal_monitoring" do
-    let!(:transaction) do
-      Appsignal::Transaction.create(
-        SecureRandom.uuid,
-        Appsignal::Transaction::HTTP_REQUEST,
-        ::Rack::Request.new(env)
+      expect(stderr).to include(
+        "appsignal WARNING: The constant Appsignal::Rack::StreamingListener " \
+          "has been deprecated."
       )
     end
-    let(:wrapper)     { Appsignal::StreamWrapper.new("body", transaction) }
-    let(:raw_payload) { { :foo => :bar } }
-
-    before do
-      allow(SecureRandom).to receive(:uuid).and_return("123")
-      allow(listener).to receive(:raw_payload).and_return(raw_payload)
-      allow(Appsignal::Transaction).to receive(:create).and_return(transaction)
-    end
-
-    it "should create a transaction" do
-      expect(Appsignal::Transaction).to receive(:create)
-        .with("123", Appsignal::Transaction::HTTP_REQUEST, instance_of(Rack::Request))
-        .and_return(transaction)
-
-      listener.call_with_appsignal_monitoring(env)
-    end
-
-    it "should instrument the call" do
-      expect(Appsignal).to receive(:instrument)
-        .with("process_action.rack")
-        .and_yield
-
-      listener.call_with_appsignal_monitoring(env)
-    end
-
-    it "should add `appsignal.action` to the transaction" do
-      allow(Appsignal).to receive(:instrument).and_yield
-
-      env["appsignal.action"] = "Action"
-
-      expect(transaction).to receive(:set_action_if_nil).with("Action")
-
-      listener.call_with_appsignal_monitoring(env)
-    end
-
-    it "should add the path, method and queue start to the transaction" do
-      allow(Appsignal).to receive(:instrument).and_yield
 
-      expect(transaction).to receive(:set_metadata).with("path", "/homepage")
-      expect(transaction).to receive(:set_metadata).with("method", "GET")
-      expect(transaction).to receive(:set_http_or_background_queue_start)
-
-      listener.call_with_appsignal_monitoring(env)
-    end
-
-    context "with an exception in the instrumentation call" do
-      let(:error) { ExampleException }
-
-      it "should add the exception to the transaction" do
-        allow(app).to receive(:call).and_raise(error)
-
-        expect(transaction).to receive(:set_error).with(error)
-
-        expect do
-          listener.call_with_appsignal_monitoring(env)
-        end.to raise_error(error)
-      end
-    end
-
-    it "should wrap the body in a wrapper" do
-      expect(Appsignal::StreamWrapper).to receive(:new)
-        .with("body", transaction)
-        .and_return(wrapper)
-
-      body = listener.call_with_appsignal_monitoring(env)[2]
-
-      expect(body).to be_a(Appsignal::StreamWrapper)
+    it "logs a warning" do
+      logs =
+        capture_logs do
+          silence do
+            load_middleware
+          end
+        end
+
+      expect(logs).to contains_log(
+        :warn,
+        "The constant Appsignal::Rack::StreamingListener has been deprecated."
+      )
     end
   end
-end
-
-describe Appsignal::StreamWrapper do
-  let(:stream)      { double }
-  let(:transaction) do
-    Appsignal::Transaction.create(SecureRandom.uuid, Appsignal::Transaction::HTTP_REQUEST, {})
-  end
-  let(:wrapper) { Appsignal::StreamWrapper.new(stream, transaction) }
 
-  describe "#each" do
-    it "calls the original stream" do
-      expect(stream).to receive(:each)
+  describe "middleware" do
+    let(:env) { {} }
+    let(:app) { DummyApp.new }
+    let(:middleware) { Appsignal::Rack::StreamingListener.new(app, {}) }
+    around { |example| keep_transactions { example.run } }
+    before(:context) { load_middleware }
+    before { start_agent }
 
-      wrapper.each
+    def make_request
+      middleware.call(env)
     end
 
-    context "when #each raises an error" do
-      let(:error) { ExampleException }
-
-      it "records the exception" do
-        allow(stream).to receive(:each).and_raise(error)
-
-        expect(transaction).to receive(:set_error).with(error)
+    it "instruments the call" do
+      make_request
 
-        expect { wrapper.send(:each) }.to raise_error(error)
-      end
+      expect(last_transaction).to include_event("name" => "process_streaming_request.rack")
     end
-  end
 
-  describe "#close" do
-    it "closes the original stream and completes the transaction" do
-      expect(stream).to receive(:close)
-      expect(Appsignal::Transaction).to receive(:complete_current!)
+    it "set no action by default" do
+      make_request
 
-      wrapper.close
+      expect(last_transaction).to_not have_action
     end
 
-    context "when #close raises an error" do
-      let(:error) { ExampleException }
-
-      it "records the exception and completes the transaction" do
-        allow(stream).to receive(:close).and_raise(error)
+    it "set `appsignal.action` to the action name" do
+      env["appsignal.action"] = "Action"
 
-        expect(transaction).to receive(:set_error).with(error)
-        expect(transaction).to receive(:complete)
+      make_request
 
-        expect { wrapper.send(:close) }.to raise_error(error)
-      end
+      expect(last_transaction).to have_action("Action")
     end
   end
 end