appsignal 3.4.4 → 3.7.0

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

@@ -1,39 +1,49 @@
 if DependencyHelper.sinatra_present?
   require "appsignal/integrations/sinatra"
 
+  module SinatraRequestHelpers
+    def make_request(env)
+      middleware.call(env)
+    end
+
+    def make_request_with_error(env, error)
+      expect { middleware.call(env) }.to raise_error(error)
+    end
+  end
+
   describe Appsignal::Rack::SinatraInstrumentation do
+    include SinatraRequestHelpers
+
     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) }
 
+    before(:context) { start_agent }
+    around do |example|
+      keep_transactions { example.run }
+    end
+
     describe "#call" do
-      before do
-        start_agent
-        allow(middleware).to receive(:raw_payload).and_return({})
-        allow(Appsignal).to receive(:active?).and_return(true)
-      end
+      before { allow(middleware).to receive(:raw_payload).and_return({}) }
 
-      it "should call without monitoring" do
-        expect(Appsignal::Transaction).to_not receive(:create)
+      it "doesn't instrument requests" do
+        make_request(env)
+        expect(created_transactions.count).to eq(0)
       end
-
-      after { middleware.call(env) }
     end
 
     describe ".settings" do
       subject { middleware.settings }
 
-      it "should return the app's settings" do
+      it "returns 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
+    include SinatraRequestHelpers
 
     let(:settings) { double(:raise_errors => false) }
     let(:app) { double(:call => true, :settings => settings) }
@@ -41,11 +51,16 @@ if DependencyHelper.sinatra_present?
     let(:options) { {} }
     let(:middleware) { Appsignal::Rack::SinatraBaseInstrumentation.new(app, options) }
 
+    before(:context) { start_agent }
+    around do |example|
+      keep_transactions { example.run }
+    end
+
     describe "#initialize" do
       context "with no settings method in the Sinatra app" do
         let(:app) { double(:call => true) }
 
-        it "should not raise errors" do
+        it "does not raise errors" do
           expect(middleware.raise_errors_on).to be(false)
         end
       end
@@ -53,7 +68,7 @@ if DependencyHelper.sinatra_present?
       context "with no raise_errors setting in the Sinatra app" do
         let(:app) { double(:call => true, :settings => double) }
 
-        it "should not raise errors" do
+        it "does not raise errors" do
           expect(middleware.raise_errors_on).to be(false)
         end
       end
@@ -61,7 +76,7 @@ if DependencyHelper.sinatra_present?
       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
+        it "raises errors" do
           expect(middleware.raise_errors_on).to be(false)
         end
       end
@@ -69,21 +84,17 @@ if DependencyHelper.sinatra_present?
       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
+        it "raises 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
+      before { allow(middleware).to receive(:raw_payload).and_return({}) }
 
       context "when appsignal is active" do
-        before { allow(Appsignal).to receive(:active?).and_return(true) }
-
-        it "should call with monitoring" do
+        it "instruments requests" do
           expect(middleware).to receive(:call_with_appsignal_monitoring).with(env)
         end
       end
@@ -91,34 +102,36 @@ if DependencyHelper.sinatra_present?
       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)
+        it "does not instrument requests" do
+          expect(created_transactions.count).to eq(0)
         end
 
-        it "should call the stack" do
+        it "calls the next middleware in the stack" do
           expect(app).to receive(:call).with(env)
         end
       end
 
-      after { middleware.call(env) }
+      after { make_request(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
+    describe "#call_with_appsignal_monitoring" do
+      context "without an error" do
+        it "creates a transaction" do
+          expect(app).to receive(:call).with(env)
+
+          make_request(env)
 
-      it "should call the app" do
-        expect(app).to receive(:call).with(env)
+          expect(created_transactions.count).to eq(1)
+          expect(last_transaction.to_h).to include(
+            "namespace" => Appsignal::Transaction::HTTP_REQUEST,
+            "action" => "GET /",
+            "error" => nil,
+            "metadata" => { "path" => "" }
+          )
+        end
       end
 
-      context "with an error", :error => true do
+      context "with an error" do
         let(:error) { ExampleException }
         let(:app) do
           double.tap do |d|
@@ -128,23 +141,48 @@ if DependencyHelper.sinatra_present?
         end
 
         it "records the exception" do
-          expect_any_instance_of(Appsignal::Transaction).to receive(:set_error).with(error)
+          make_request_with_error(env, error)
+
+          expect(created_transactions.count).to eq(1)
+          expect(last_transaction.to_h).to include(
+            "namespace" => Appsignal::Transaction::HTTP_REQUEST,
+            "action" => "GET /",
+            "error" => hash_including(
+              "name" => "ExampleException",
+              "message" => "ExampleException"
+            )
+          )
         end
       end
 
       context "with an error in sinatra.error" do
-        let(:error) { ExampleException }
+        let(:error) { ExampleException.new }
         let(:env) { { "sinatra.error" => error } }
 
-        it "records the exception" do
-          expect_any_instance_of(Appsignal::Transaction).to receive(:set_error).with(error)
+        context "when raise_errors is off" do
+          let(:settings) { double(:raise_errors => false) }
+
+          it "record the error" do
+            make_request(env)
+
+            expect(created_transactions.count).to eq(1)
+            expect(last_transaction.to_h).to include(
+              "error" => hash_including(
+                "name" => "ExampleException",
+                "message" => "ExampleException"
+              )
+            )
+          end
         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)
+            make_request(env)
+
+            expect(created_transactions.count).to eq(1)
+            expect(last_transaction.to_h).to include("error" => nil)
           end
         end
 
@@ -152,22 +190,30 @@ if DependencyHelper.sinatra_present?
           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)
+            make_request(env)
+
+            expect(created_transactions.count).to eq(1)
+            expect(last_transaction.to_h).to include("error" => nil)
           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 /")
+        it "sets the action" do
+          make_request(env)
+
+          expect(created_transactions.count).to eq(1)
+          expect(last_transaction.to_h).to include("action" => "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)
+          it "doesn't set an action name" do
+            make_request(env)
+
+            expect(created_transactions.count).to eq(1)
+            expect(last_transaction.to_h).to include("action" => nil)
           end
         end
 
@@ -175,44 +221,90 @@ if DependencyHelper.sinatra_present?
           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/")
+            make_request(env)
+
+            expect(created_transactions.count).to eq(1)
+            expect(last_transaction.to_h).to include("action" => "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)
+            it "doesn't set an action name" do
+              make_request(env)
+
+              expect(created_transactions.count).to eq(1)
+              expect(last_transaction.to_h).to include("action" => nil)
             end
           end
         end
       end
 
-      it "should set metadata" do
-        expect_any_instance_of(Appsignal::Transaction).to receive(:set_metadata).twice
+      context "metadata" do
+        let(:env) { { "PATH_INFO" => "/some/path", "REQUEST_METHOD" => "GET" } }
+
+        it "sets metadata from the environment" do
+          make_request(env)
+
+          expect(created_transactions.count).to eq(1)
+          expect(last_transaction.to_h).to include(
+            "metadata" => {
+              "method" => "GET",
+              "path" => "/some/path"
+            },
+            "sample_data" => hash_including(
+              "environment" => hash_including(
+                "REQUEST_METHOD" => "GET",
+                "PATH_INFO" => "/some/path"
+              )
+            )
+          )
+        end
+      end
+
+      context "with queue start" do
+        let(:queue_start_time) { fixed_time * 1_000 }
+        let(:env) do
+          { "HTTP_X_REQUEST_START" => "t=#{queue_start_time.to_i}" } # in milliseconds
+        end
+
+        it "sets the queue start" do
+          make_request(env)
+          expect(last_transaction.ext.queue_start).to eq(queue_start_time)
+        end
       end
 
-      it "should set the queue start" do
-        expect_any_instance_of(Appsignal::Transaction)
-          .to receive(:set_http_or_background_queue_start)
+      class FilteredRequest
+        def initialize(_args) # rubocop:disable Style/RedundantInitialize
+        end
+
+        def path
+          "/static/path"
+        end
+
+        def request_method
+          "GET"
+        end
+
+        def filtered_params
+          { "abc" => "123" }
+        end
       end
 
       context "with overridden request class and params method" do
-        let(:options) { { :request_class => ::Rack::Request, :params_method => :filtered_params } }
+        let(:options) { { :request_class => FilteredRequest, :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)
+        it "uses the overridden request class and params method to fetch params" do
+          make_request(env)
+
+          expect(created_transactions.count).to eq(1)
+          expect(last_transaction.to_h).to include(
+            "sample_data" => hash_including(
+              "params" => { "abc" => "123" }
+            )
+          )
         end
       end
-
-      after(:error => false) { middleware.call(env) }
-      after(:error => true) { expect { middleware.call(env) }.to raise_error(error) }
     end
   end
 end

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

@@ -1,6 +1,7 @@
 require "appsignal/rack/streaming_listener"
 
 describe Appsignal::Rack::StreamingListener do
+  before(:context) { start_agent }
   let(:headers) { {} }
   let(:env) do
     {

data/spec/lib/appsignal/transaction_spec.rb

@@ -303,7 +303,7 @@ describe Appsignal::Transaction do
         context "with overridden options" do
           let(:options) { { :params_method => :filtered_params } }
 
-          it "sets the overriden :params_method" do
+          it "sets the overridden :params_method" do
             expect(subject[:params_method]).to eq :filtered_params
           end
         end
@@ -355,7 +355,7 @@ describe Appsignal::Transaction do
     end
 
     describe "#set_tags" do
-      let(:long_string) { "a" * 2001 }
+      let(:long_string) { "a" * 10_001 }
       before do
         transaction.set_tags(
           :valid_key => "valid_value",
@@ -377,7 +377,7 @@ describe Appsignal::Transaction do
           "valid_string_key" => "valid_value",
           "both_symbols" => "valid_value",
           "integer_value" => 1,
-          "too_long_value" => "#{"a" * 2000}...",
+          "too_long_value" => "#{"a" * 10_000}...",
           long_string => "too_long_key"
         )
       end
@@ -432,6 +432,19 @@ describe Appsignal::Transaction do
           expect(breadcrumb["metadata"]).to eq({})
         end
       end
+
+      context "with metadata argument that's not a Hash" do
+        it "does not add the breadcrumb and logs and error" do
+          transaction.add_breadcrumb("category", "action", "message", "invalid metadata")
+          transaction.sample_data
+
+          expect(transaction.to_h["sample_data"]["breadcrumbs"]).to be_empty
+          expect(log_contents(log)).to contains_log(
+            :error,
+            "add_breadcrumb: Cannot add breadcrumb. The given metadata argument is not a Hash."
+          )
+        end
+      end
     end
 
     describe "#set_action" do
@@ -567,7 +580,7 @@ describe Appsignal::Transaction do
       it "does not raise an error when the queue start is too big" do
         expect(transaction.ext).to receive(:set_queue_start).and_raise(RangeError)
 
-        expect(Appsignal.logger).to receive(:warn).with("Queue start value 10 is too big")
+        expect(Appsignal.internal_logger).to receive(:warn).with("Queue start value 10 is too big")
 
         expect do
           transaction.set_queue_start(10)
@@ -623,6 +636,18 @@ describe Appsignal::Transaction do
         expect(transaction.to_h["metadata"]).to eq("request_method" => "GET")
       end
 
+      context "when filter_metadata includes metadata key" do
+        before { Appsignal.config[:filter_metadata] = ["filter_key"] }
+        after { Appsignal.config[:filter_metadata] = [] }
+
+        it "does not set the metadata on the transaction" do
+          transaction.set_metadata(:filter_key, "filtered value")
+          transaction.set_metadata("filter_key", "filtered value")
+
+          expect(transaction.to_h["metadata"].keys).to_not include("filter_key")
+        end
+      end
+
       context "when the key is nil" do
         it "does not update the metadata on the transaction" do
           transaction.set_metadata(nil, "GET")
@@ -663,6 +688,8 @@ describe Appsignal::Transaction do
           transaction.set_sample_data("params", "string")
 
           expect(transaction.to_h["sample_data"]).to eq({})
+          expect(log_contents(log)).to contains_log :error,
+            %(Invalid sample data for 'params'. Value is not an Array or Hash: '"string"')
         end
       end
 
@@ -724,7 +751,7 @@ describe Appsignal::Transaction do
         e
       end
 
-      it "should also respond to add_exception for backwords compatibility" do
+      it "should also respond to add_exception for backwards compatibility" do
         expect(transaction).to respond_to(:add_exception)
       end
 
@@ -739,7 +766,7 @@ describe Appsignal::Transaction do
         let(:error) { Object.new }
 
         it "does not add the error" do
-          expect(Appsignal.logger).to receive(:error).with(
+          expect(Appsignal.internal_logger).to receive(:error).with(
             "Appsignal::Transaction#set_error: Cannot set error. " \
               "The given value is not an exception: #{error.inspect}"
           )
@@ -761,6 +788,99 @@ describe Appsignal::Transaction do
         end
       end
 
+      context "when the error has no causes" do
+        it "should not send the causes information as sample data" do
+          expect(transaction.ext).to_not receive(:set_sample_data)
+
+          transaction.set_error(error)
+        end
+      end
+
+      context "when the error has multiple causes" do
+        let(:error) do
+          e = ExampleStandardError.new("test message")
+          e2 = RuntimeError.new("cause message")
+          e3 = StandardError.new("cause message 2")
+          allow(e).to receive(:backtrace).and_return(["line 1"])
+          allow(e).to receive(:cause).and_return(e2)
+          allow(e2).to receive(:cause).and_return(e3)
+          e
+        end
+
+        it "sends the causes information as sample data" do
+          expect(transaction.ext).to receive(:set_error).with(
+            "ExampleStandardError",
+            "test message",
+            Appsignal::Utils::Data.generate(["line 1"])
+          )
+
+          expect(transaction.ext).to receive(:set_sample_data).with(
+            "error_causes",
+            Appsignal::Utils::Data.generate(
+              [
+                {
+                  :name => "RuntimeError",
+                  :message => "cause message"
+                },
+                {
+                  :name => "StandardError",
+                  :message => "cause message 2"
+                }
+              ]
+            )
+          )
+
+          expect(Appsignal.internal_logger).to_not receive(:debug)
+
+          transaction.set_error(error)
+        end
+      end
+
+      context "when the error has too many causes" do
+        let(:error) do
+          e = ExampleStandardError.new("root cause error")
+
+          11.times do |i|
+            next_e = ExampleStandardError.new("wrapper error #{i}")
+            allow(next_e).to receive(:cause).and_return(e)
+            e = next_e
+          end
+
+          allow(e).to receive(:backtrace).and_return(["line 1"])
+          e
+        end
+
+        it "sends only the first causes as sample data" do
+          expect(transaction.ext).to receive(:set_error).with(
+            "ExampleStandardError",
+            "wrapper error 10",
+            Appsignal::Utils::Data.generate(["line 1"])
+          )
+
+          expected_error_causes = Array.new(10) do |i|
+            {
+              :name => "ExampleStandardError",
+              :message => "wrapper error #{9 - i}"
+            }
+          end
+
+          expected_error_causes.last[:is_root_cause] = false
+
+          expect(transaction.ext).to receive(:set_sample_data).with(
+            "error_causes",
+            Appsignal::Utils::Data.generate(expected_error_causes)
+          )
+
+          expect(Appsignal.internal_logger).to receive(:debug).with(
+            "Appsignal::Transaction#set_error: Error has more " \
+              "than 10 error causes. Only the first 10 " \
+              "will be reported."
+          )
+
+          transaction.set_error(error)
+        end
+      end
+
       context "when error message is nil" do
         let(:error) do
           e = ExampleStandardError.new
@@ -1275,8 +1395,8 @@ describe Appsignal::Transaction do
       end
     end
 
-    describe "#metadata" do
-      subject { transaction.send(:metadata) }
+    describe "#sanitized_metadata" do
+      subject { transaction.send(:sanitized_metadata) }
 
       context "when request is nil" do
         let(:request) { nil }
@@ -1291,9 +1411,18 @@ describe Appsignal::Transaction do
       end
 
       context "when env is present" do
-        let(:env) { { :metadata => { :key => "value" } } }
+        let(:env) { { "key" => "value" } }
 
-        it { is_expected.to eq env[:metadata] }
+        it { is_expected.to eq("key" => "value") }
+
+        context "with filter_metadata option set" do
+          before { Appsignal.config[:filter_metadata] = ["key"] }
+          after { Appsignal.config[:filter_metadata] = [] }
+
+          it "filters out keys listed in the filter_metadata option" do
+            expect(subject.keys).to_not include("key")
+          end
+        end
       end
     end