appsignal 2.8.4.beta.1 → 2.9.18.beta.1

data/spec/lib/appsignal/system_spec.rb

@@ -19,41 +19,6 @@ describe Appsignal::System do
     end
   end
 
-  describe ".installed_agent_architecture" do
-    let(:const_name) { "GEM_EXT_PATH".freeze }
-    let(:tmp_ext_dir) { File.join(tmp_dir, "ext") }
-    let(:architecture_file) { File.join(Appsignal::System::GEM_EXT_PATH, "appsignal.architecture") }
-    around do |example|
-      original_gem_ext_path = Appsignal::System.const_get(const_name)
-      Appsignal::System.send(:remove_const, const_name)
-      Appsignal::System.const_set(const_name, tmp_ext_dir)
-      example.run
-      Appsignal::System.send(:remove_const, const_name)
-      Appsignal::System.const_set(const_name, original_gem_ext_path)
-    end
-    after { FileUtils.rm_rf(tmp_ext_dir) }
-    subject { described_class.installed_agent_architecture }
-
-    context "with an ext/appsignal.architecture file" do
-      before do
-        FileUtils.mkdir_p(Appsignal::System::GEM_EXT_PATH)
-        File.open(architecture_file, "w") do |file|
-          file.write "foo"
-        end
-      end
-
-      it "returns the contents of the file" do
-        expect(subject).to eq("foo")
-      end
-    end
-
-    context "without an ext/appsignal.architecture file" do
-      it "returns nil" do
-        expect(subject).to be_nil
-      end
-    end
-  end
-
   describe ".agent_platform" do
     let(:os) { "linux-gnu" }
     let(:ldd_output) { "" }

data/spec/lib/appsignal/transaction_spec.rb

@@ -214,7 +214,7 @@ describe Appsignal::Transaction do
 
   context "pausing" do
     describe "#pause!" do
-      it "should change the pause flag to true" do
+      it "changes the pause flag to true" do
         expect do
           transaction.pause!
         end.to change(transaction, :paused).from(false).to(true)
@@ -224,7 +224,7 @@ describe Appsignal::Transaction do
     describe "#resume!" do
       before { transaction.pause! }
 
-      it "should change the pause flag to false" do
+      it "changes the pause flag to false" do
         expect do
           transaction.resume!
         end.to change(transaction, :paused).from(true).to(false)
@@ -232,14 +232,16 @@ describe Appsignal::Transaction do
     end
 
     describe "#paused?" do
-      it "should return the pause state" do
-        expect(transaction.paused?).to be_falsy
+      context "when not paused" do
+        it "return false" do
+          expect(transaction.paused?).to be_falsy
+        end
       end
 
       context "when paused" do
         before { transaction.pause! }
 
-        it "should return the pause state" do
+        it "returns true" do
           expect(transaction.paused?).to be_truthy
         end
       end
@@ -628,7 +630,11 @@ describe Appsignal::Transaction do
 
     describe "#set_error" do
       let(:env) { http_request_env_with_data }
-      let(:error) { double(:error, :message => "test message", :backtrace => ["line 1"]) }
+      let(:error) do
+        e = ExampleStandardError.new("test message")
+        allow(e).to receive(:backtrace).and_return(["line 1"])
+        e
+      end
 
       it "should also respond to add_exception for backwords compatibility" do
         expect(transaction).to respond_to(:add_exception)
@@ -641,10 +647,24 @@ describe Appsignal::Transaction do
         transaction.set_error(error)
       end
 
+      context "when error is not an error" do
+        let(:error) { Object.new }
+
+        it "does not add the error" do
+          expect(Appsignal.logger).to receive(:error).with(
+            "Appsignal::Transaction#set_error: Cannot set error. " \
+            "The given value is not an exception: #{error.inspect}"
+          )
+          expect(transaction.ext).to_not receive(:set_error)
+
+          transaction.set_error(error)
+        end
+      end
+
       context "for a http request" do
         it "should set an error in the extension" do
           expect(transaction.ext).to receive(:set_error).with(
-            "RSpec::Mocks::Double",
+            "ExampleStandardError",
             "test message",
             Appsignal::Utils::Data.generate(["line 1"])
           )
@@ -654,7 +674,12 @@ describe Appsignal::Transaction do
       end
 
       context "when error message is nil" do
-        let(:error) { double(:error, :message => nil, :backtrace => ["line 1"]) }
+        let(:error) do
+          e = ExampleStandardError.new
+          allow(e).to receive(:message).and_return(nil)
+          allow(e).to receive(:backtrace).and_return(["line 1"])
+          e
+        end
 
         it "should not raise an error" do
           expect { transaction.set_error(error) }.to_not raise_error
@@ -662,7 +687,7 @@ describe Appsignal::Transaction do
 
         it "should set an error in the extension" do
           expect(transaction.ext).to receive(:set_error).with(
-            "RSpec::Mocks::Double",
+            "ExampleStandardError",
             "",
             Appsignal::Utils::Data.generate(["line 1"])
           )
@@ -690,11 +715,20 @@ describe Appsignal::Transaction do
     end
 
     describe "#start_event" do
-      it "should start the event in the extension" do
+      it "starts the event in the extension" do
         expect(transaction.ext).to receive(:start_event).with(0).and_call_original
 
         transaction.start_event
       end
+
+      context "when transaction is paused" do
+        it "does not start the event" do
+          transaction.pause!
+          expect(transaction.ext).to_not receive(:start_event)
+
+          transaction.start_event
+        end
+      end
     end
 
     describe "#finish_event" do
@@ -737,6 +771,15 @@ describe Appsignal::Transaction do
           nil
         )
       end
+
+      context "when transaction is paused" do
+        it "does not finish the event" do
+          transaction.pause!
+          expect(transaction.ext).to_not receive(:finish_event)
+
+          transaction.start_event
+        end
+      end
     end
 
     describe "#record_event" do
@@ -783,6 +826,21 @@ describe Appsignal::Transaction do
           nil
         )
       end
+
+      context "when transaction is paused" do
+        it "does not record the event" do
+          transaction.pause!
+          expect(transaction.ext).to_not receive(:record_event)
+
+          transaction.record_event(
+            "name",
+            nil,
+            nil,
+            1000,
+            nil
+          )
+        end
+      end
     end
 
     describe "#instrument" do

data/spec/lib/appsignal/utils/hash_sanitizer_spec.rb

@@ -30,19 +30,20 @@ describe Appsignal::Utils::HashSanitizer do
     let(:sanitized_params) { described_class.sanitize(params) }
     subject { sanitized_params }
 
-    it { is_expected.to be_instance_of Hash }
-    it { expect(subject[:text]).to eq("string") }
-    it { expect(subject["string"]).to eq("string key value") }
-    it do
+    it "returns a sanitized Hash" do
+      expect(subject).to_not eq(params)
+      is_expected.to be_instance_of Hash
+      expect(subject[:text]).to eq("string")
+      expect(subject["string"]).to eq("string key value")
       expect(subject[:file]).to be_instance_of String
       expect(subject[:file]).to include "::UploadedFile"
+      expect(subject[:float]).to eq(0.0)
+      expect(subject[:bool_true]).to be(true)
+      expect(subject[:bool_false]).to be(false)
+      expect(subject[:nil]).to be_nil
+      expect(subject[:int]).to eq(1)
+      expect(subject[:int64]).to eq(1 << 64)
     end
-    it { expect(subject[:float]).to eq(0.0) }
-    it { expect(subject[:bool_true]).to be(true) }
-    it { expect(subject[:bool_false]).to be(false) }
-    it { expect(subject[:nil]).to be_nil }
-    it { expect(subject[:int]).to eq(1) }
-    it { expect(subject[:int64]).to eq(1 << 64) }
 
     it "does not change the original params" do
       subject
@@ -50,29 +51,34 @@ describe Appsignal::Utils::HashSanitizer do
       expect(params[:hash][:nested_array][2]).to eq(file)
     end
 
-    describe ":hash" do
+    describe ":hash key" do
       subject { sanitized_params[:hash] }
 
-      it { is_expected.to be_instance_of Hash }
-      it { expect(subject[:nested_text]).to eq("string") }
+      it "returns a sanitized Hash" do
+        expect(subject).to_not eq(params[:hash])
+        is_expected.to be_instance_of Hash
+        expect(subject[:nested_text]).to eq("string")
+      end
 
-      describe ":nested_array" do
+      describe ":nested_array key" do
         subject { sanitized_params[:hash][:nested_array] }
 
-        it { is_expected.to be_instance_of Array }
-        it { expect(subject[0]).to eq("something") }
-        it { expect(subject[1]).to eq("else") }
-        it do
+        it "returns a sanitized Array" do
+          expect(subject).to_not eq(params[:hash][:nested_array])
+          is_expected.to be_instance_of Array
+          expect(subject[0]).to eq("something")
+          expect(subject[1]).to eq("else")
           expect(subject[2]).to be_instance_of String
           expect(subject[2]).to include "::UploadedFile"
         end
 
-        describe ":nested_hash" do
+        describe ":nested_hash key" do
           subject { sanitized_params[:hash][:nested_array][3] }
 
-          it { is_expected.to be_instance_of Hash }
-          it { expect(subject[:key]).to eq("value") }
-          it do
+          it "returns a sanitized Hash" do
+            expect(subject).to_not eq(params[:hash][:nested_array][3])
+            is_expected.to be_instance_of Hash
+            expect(subject[:key]).to eq("value")
             expect(subject[:file]).to be_instance_of String
             expect(subject[:file]).to include "::UploadedFile"
           end
@@ -86,17 +92,19 @@ describe Appsignal::Utils::HashSanitizer do
       end
       subject { sanitized_params }
 
-      it { expect(subject[:text]).to eq(described_class::FILTERED) }
-      it { expect(subject[:hash]).to eq(described_class::FILTERED) }
-      it do
+      it "returns a sanitized Hash with the given keys filtered out" do
+        expect(subject).to_not eq(params)
+        expect(subject[:text]).to eq(described_class::FILTERED)
+        expect(subject[:hash]).to eq(described_class::FILTERED)
+
         expect(subject[:file]).to be_instance_of String
         expect(subject[:file]).to include "::UploadedFile"
+        expect(subject[:float]).to eq(0.0)
+        expect(subject[:bool_true]).to be(true)
+        expect(subject[:bool_false]).to be(false)
+        expect(subject[:nil]).to be_nil
+        expect(subject[:int]).to eq(1)
       end
-      it { expect(subject[:float]).to eq(0.0) }
-      it { expect(subject[:bool_true]).to be(true) }
-      it { expect(subject[:bool_false]).to be(false) }
-      it { expect(subject[:nil]).to be_nil }
-      it { expect(subject[:int]).to eq(1) }
 
       context "with strings as key filter values" do
         let(:sanitized_params) do
@@ -108,7 +116,7 @@ describe Appsignal::Utils::HashSanitizer do
         end
       end
 
-      describe ":hash" do
+      describe ":hash key" do
         let(:sanitized_params) do
           described_class.sanitize(params, %w[nested_text])
         end

data/spec/lib/appsignal/utils/json_spec.rb

@@ -16,10 +16,12 @@ describe Appsignal::Utils::JSON do
         }
       end
 
-      it { is_expected.to eq %({"the":"payload","1":true,"":"test","foo":[1,2,"three"],"bar":null,"baz":{"foo":"bar"}}) }
+      it "returns a JSON string" do
+        is_expected.to eq %({"the":"payload","1":true,"":"test","foo":[1,2,"three"],"bar":null,"baz":{"foo":"bar"}})
+      end
     end
 
-    context "with a body that contains strings with invalid utf-8 content" do
+    context "with a body that contains strings with invalid UTF-8 content" do
       let(:string_with_invalid_utf8) { [0x61, 0x61, 0x85].pack("c*") }
       let(:body) do
         {
@@ -34,7 +36,9 @@ describe Appsignal::Utils::JSON do
         }
       end
 
-      it { is_expected.to eq %({"field_one":"aa","field_two":"aa�","field_three":["one","aa�"],"field_four":{"one":"aa�"}}) }
+      it "returns a JSON string with invalid UTF-8 content" do
+        is_expected.to eq %({"field_one":"aa","field_two":"aa�","field_three":["one","aa�"],"field_four":{"one":"aa�"}})
+      end
     end
   end
 end

data/spec/lib/appsignal_spec.rb

@@ -90,14 +90,10 @@ describe Appsignal do
         unless Appsignal::System.jruby?
           it "installs the allocation event hook" do
             expect(Appsignal::Extension).to receive(:install_allocation_event_hook)
+              .and_call_original
             Appsignal.start
           end
         end
-
-        it "should add the gc probe to minutely" do
-          expect(Appsignal::Minutely).to receive(:add_gc_probe)
-          Appsignal.start
-        end
       end
 
       context "when allocation tracking and gc instrumentation have been disabled" do
@@ -117,7 +113,7 @@ describe Appsignal do
         end
 
         it "should not add the gc probe to minutely" do
-          expect(Appsignal::Minutely).not_to receive(:add_gc_probe)
+          expect(Appsignal::Minutely).not_to receive(:register_garbage_collection_probe)
           Appsignal.start
         end
       end
@@ -244,6 +240,16 @@ describe Appsignal do
 
   context "not active" do
     describe ".monitor_transaction" do
+      let(:log_stream) { StringIO.new }
+      let(:log) { log_contents(log_stream) }
+      before do
+        Appsignal.config = project_fixture_config("not_active")
+        Appsignal.start
+        Appsignal.start_logger
+        Appsignal.logger = test_logger(log_stream)
+      end
+      after { Appsignal.logger = nil }
+
       it "should do nothing but still yield the block" do
         expect(Appsignal::Transaction).to_not receive(:create)
         expect(Appsignal).to_not receive(:instrument)
@@ -256,6 +262,23 @@ describe Appsignal do
           end).to eq 1
         end.to_not raise_error
       end
+
+      context "with an unknown event type" do
+        it "yields the given block" do
+          expect do |blk|
+            Appsignal.monitor_transaction("unknown.sidekiq", &blk)
+          end.to yield_control
+        end
+
+        it "logs an error" do
+          Appsignal.monitor_transaction("unknown.sidekiq") {}
+          expect(log).to contains_log(
+            :error,
+            "Unrecognized name 'unknown.sidekiq': names must start with either 'perform_job' " \
+              "(for jobs and tasks) or 'process_action' (for HTTP requests)"
+          )
+        end
+      end
     end
 
     describe ".listen_for_error" do
@@ -303,10 +326,15 @@ describe Appsignal do
   end
 
   context "with config and started" do
+    let(:log_stream) { StringIO.new }
+    let(:log) { log_contents(log_stream) }
     before do
       Appsignal.config = project_fixture_config
       Appsignal.start
+      Appsignal.start_logger
+      Appsignal.logger = test_logger(log_stream)
     end
+    after { Appsignal.logger = nil }
 
     describe ".monitor_transaction" do
       context "with a successful call" do
@@ -363,6 +391,23 @@ describe Appsignal do
           end.to raise_error(error)
         end
       end
+
+      context "with an unknown event type" do
+        it "yields the given block" do
+          expect do |blk|
+            Appsignal.monitor_transaction("unknown.sidekiq", &blk)
+          end.to yield_control
+        end
+
+        it "logs an error" do
+          Appsignal.monitor_transaction("unknown.sidekiq") {}
+          expect(log).to contains_log(
+            :error,
+            "Unrecognized name 'unknown.sidekiq': names must start with either 'perform_job' " \
+              "(for jobs and tasks) or 'process_action' (for HTTP requests)"
+          )
+        end
+      end
     end
 
     describe ".monitor_single_transaction" do
@@ -612,8 +657,10 @@ describe Appsignal do
         let(:error) { double }
 
         it "logs an error message" do
-          expect(Appsignal.logger).to receive(:error)
-            .with("Can't send error, given value is not an exception")
+          expect(Appsignal.logger).to receive(:error).with(
+            "Appsignal.send_error: Cannot send error. " \
+              "The given value is not an exception: #{error.inspect}"
+          )
         end
 
         it "does not send the error" do
@@ -650,6 +697,29 @@ describe Appsignal do
 
         after { Appsignal.send_error(error, nil, namespace) }
       end
+
+      context "when given a block" do
+        it "yields the transaction and allows additional metadata to be set" do
+          captured_transaction = nil
+          Appsignal.send_error(StandardError.new("my_error")) do |transaction|
+            captured_transaction = transaction
+            transaction.set_action("my_action")
+            transaction.set_namespace("my_namespace")
+
+            # Don't flush the transaction, so we can inspect it
+            expect(transaction).to receive(:complete)
+          end
+          expect(captured_transaction.to_h).to include(
+            "namespace" => "my_namespace",
+            "action" => "my_action",
+            "error" => {
+              "name" => "StandardError",
+              "message" => "my_error",
+              "backtrace" => kind_of(String) # TODO: should be Array
+            }
+          )
+        end
+      end
     end
 
     describe ".listen_for_error" do
@@ -710,13 +780,19 @@ describe Appsignal do
           Appsignal.set_error(error)
         end
 
-        context "when the error is nil" do
-          it "does nothing" do
+        context "when the error is not an Exception" do
+          let(:error) { Object.new }
+
+          it "logs an error" do
+            expect(Appsignal.logger).to receive(:error).with(
+              "Appsignal.set_error: Cannot set error. " \
+                "The given value is not an exception: #{error.inspect}"
+            )
             expect(transaction).to_not receive(:set_error)
             expect(transaction).to_not receive(:set_tags)
             expect(transaction).to_not receive(:set_namespace)
 
-            Appsignal.set_error(nil)
+            Appsignal.set_error(error)
           end
         end
 
@@ -831,25 +907,25 @@ describe Appsignal do
     end
 
     describe ".without_instrumentation" do
-      let(:transaction) { double }
+      let(:transaction) { http_request_transaction }
       before { allow(Appsignal::Transaction).to receive(:current).and_return(transaction) }
 
-      it "should pause and unpause the transaction around the block" do
-        expect(transaction).to receive(:pause!)
-        expect(transaction).to receive(:resume!)
+      it "does not record events on the transaction" do
+        expect(transaction).to receive(:pause!).and_call_original
+        expect(transaction).to receive(:resume!).and_call_original
+        Appsignal.instrument("register.this.event") { :do_nothing }
+        Appsignal.without_instrumentation do
+          Appsignal.instrument("dont.register.this.event") { :do_nothing }
+        end
+        expect(transaction.to_h["events"].map { |e| e["name"] })
+          .to match_array("register.this.event")
       end
 
       context "without transaction" do
         let(:transaction) { nil }
 
         it "should not crash" do
-          # just execute the after block
-        end
-      end
-
-      after do
-        Appsignal.without_instrumentation do
-          # nothing
+          Appsignal.without_instrumentation { :do_nothing }
         end
       end
     end