appsignal 3.9.2 → 3.9.3

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

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,8 +1,6 @@
 require "appsignal/rack/streaming_listener"
 
 describe Appsignal::Rack::StreamingListener do
-  before(:context) { start_agent }
-  let(:headers) { {} }
   let(:env) do
     {
       "rack.input" => StringIO.new,
@@ -11,114 +9,96 @@ describe Appsignal::Rack::StreamingListener do
       "QUERY_STRING" => "param=something"
     }
   end
-  let(:app)      { double(:call => [200, headers, "body"]) }
+  let(:app) { DummyApp.new }
   let(:listener) { Appsignal::Rack::StreamingListener.new(app, {}) }
+  before(:context) { start_agent }
+  around { |example| keep_transactions { example.run } }
 
   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) }
 
-      it "should not call `call_with_appsignal_monitoring`" do
-        expect(listener).to_not receive(:call_with_appsignal_monitoring)
+      it "does not create a transaction" do
+        expect do
+          listener.call(env)
+        end.to_not(change { created_transactions.count })
       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)
-      )
-    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 "calls the app" do
+        listener.call(env)
 
-    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)
+        expect(app).to be_called
+      end
     end
 
-    it "should instrument the call" do
-      expect(Appsignal).to receive(:instrument)
-        .with("process_action.rack")
-        .and_yield
+    context "when Appsignal is active" do
+      before { allow(Appsignal).to receive(:active?).and_return(true) }
 
-      listener.call_with_appsignal_monitoring(env)
-    end
+      let(:wrapper) { Appsignal::StreamWrapper.new("body", transaction) }
+      let(:raw_payload) { { :foo => :bar } }
+      before { allow(listener).to receive(:raw_payload).and_return(raw_payload) }
 
-    it "should add `appsignal.action` to the transaction" do
-      allow(Appsignal).to receive(:instrument).and_yield
+      it "creates a transaction" do
+        expect do
+          listener.call(env)
+        end.to(change { created_transactions.count }.by(1))
+      end
 
-      env["appsignal.action"] = "Action"
+      it "instruments the call" do
+        listener.call(env)
 
-      expect(transaction).to receive(:set_action_if_nil).with("Action")
+        expect(last_transaction).to include_event("name" => "process_action.rack")
+      end
 
-      listener.call_with_appsignal_monitoring(env)
-    end
+      it "set `appsignal.action` to the action name" do
+        env["appsignal.action"] = "Action"
 
-    it "should add the path, method and queue start to the transaction" do
-      allow(Appsignal).to receive(:instrument).and_yield
+        listener.call(env)
 
-      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)
+        expect(last_transaction).to have_action("Action")
+      end
 
-      listener.call_with_appsignal_monitoring(env)
-    end
+      it "adds the path, method and queue start to the transaction" do
+        listener.call(env)
 
-    context "with an exception in the instrumentation call" do
-      let(:error) { ExampleException }
+        expect(last_transaction).to include_metadata(
+          "path" => "/homepage",
+          "method" => "GET"
+        )
+        expect(last_transaction).to have_queue_start
+      end
 
-      it "should add the exception to the transaction" do
-        allow(app).to receive(:call).and_raise(error)
+      context "with an exception in the instrumentation call" do
+        let(:error) { ExampleException.new("error message") }
+        let(:app) { DummyApp.new { raise error } }
 
-        expect(transaction).to receive(:set_error).with(error)
+        it "adds the exception to the transaction" do
+          expect do
+            listener.call(env)
+          end.to raise_error(error)
 
-        expect do
-          listener.call_with_appsignal_monitoring(env)
-        end.to raise_error(error)
+          expect(last_transaction).to have_error("ExampleException", "error message")
+        end
       end
-    end
 
-    it "should wrap the body in a wrapper" do
-      expect(Appsignal::StreamWrapper).to receive(:new)
-        .with("body", transaction)
-        .and_return(wrapper)
+      it "wraps the body in a wrapper" do
+        _, _, body = listener.call(env)
 
-      body = listener.call_with_appsignal_monitoring(env)[2]
-
-      expect(body).to be_a(Appsignal::StreamWrapper)
+        expect(body).to be_a(Appsignal::StreamWrapper)
+      end
     end
   end
 end
 
 describe Appsignal::StreamWrapper do
-  let(:stream)      { double }
-  let(:transaction) do
-    Appsignal::Transaction.create(SecureRandom.uuid, Appsignal::Transaction::HTTP_REQUEST, {})
-  end
+  let(:stream) { double }
+  let(:transaction) { http_request_transaction }
   let(:wrapper) { Appsignal::StreamWrapper.new(stream, transaction) }
+  before do
+    start_agent
+    set_current_transaction(transaction)
+  end
+  around { |example| keep_transactions { example.run } }
 
   describe "#each" do
     it "calls the original stream" do
@@ -128,14 +108,14 @@ describe Appsignal::StreamWrapper do
     end
 
     context "when #each raises an error" do
-      let(:error) { ExampleException }
+      let(:error) { ExampleException.new("error message") }
 
       it "records the exception" do
         allow(stream).to receive(:each).and_raise(error)
 
-        expect(transaction).to receive(:set_error).with(error)
-
         expect { wrapper.send(:each) }.to raise_error(error)
+
+        expect(transaction).to have_error("ExampleException", "error message")
       end
     end
   end
@@ -143,21 +123,23 @@ describe Appsignal::StreamWrapper do
   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!)
 
       wrapper.close
+
+      expect(current_transaction?).to be_falsy
+      expect(transaction).to be_completed
     end
 
     context "when #close raises an error" do
-      let(:error) { ExampleException }
+      let(:error) { ExampleException.new("error message") }
 
       it "records the exception and completes the transaction" do
         allow(stream).to receive(:close).and_raise(error)
 
-        expect(transaction).to receive(:set_error).with(error)
-        expect(transaction).to receive(:complete)
-
         expect { wrapper.send(:close) }.to raise_error(error)
+
+        expect(transaction).to have_error("ExampleException", "error message")
+        expect(transaction).to be_completed
       end
     end
   end