appsignal 3.0.0.beta.1 → 3.0.3

data/spec/lib/appsignal/transaction_spec.rb

@@ -246,6 +246,23 @@ describe Appsignal::Transaction do
         expect(transaction.ext).to_not be_nil
       end
 
+      context "when extension is not loaded", :extension_installation_failure do
+        around do |example|
+          Appsignal::Testing.without_testing { example.run }
+        end
+
+        it "does not error on missing extension method calls" do
+          expect(transaction.ext).to be_kind_of(Appsignal::Extension::MockTransaction)
+          transaction.start_event
+          transaction.finish_event(
+            "name",
+            "title",
+            "body",
+            Appsignal::EventFormatter::DEFAULT
+          )
+        end
+      end
+
       it "sets the transaction id" do
         expect(transaction.transaction_id).to eq "1"
       end

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

@@ -4,110 +4,156 @@ describe Appsignal::Utils::Data do
   describe ".generate" do
     subject { Appsignal::Utils::Data.generate(body) }
 
-    context "with a valid hash body" do
-      let(:body) do
-        {
-          "the" => "payload",
-          "int" => 1, # Fixnum
-          "int61" => 1 << 61, # Fixnum
-          "int62" => 1 << 62, # Bignum, this one still works
-          "int63" => 1 << 63, # Bignum, turnover point for C, too big for long
-          "int64" => 1 << 64, # Bignum
-          "float" => 1.0,
-          1 => true,
-          nil => "test",
-          :foo => [1, 2, "three", { "foo" => "bar" }],
-          "bar" => nil,
-          "baz" => { "foo" => "bʊr", "arr" => [1, 2] }
-        }
+    context "when extension is not loaded", :extension_installation_failure do
+      around do |example|
+        Appsignal::Testing.without_testing { example.run }
       end
 
-      it { is_expected.to eq Appsignal::Utils::Data.generate(body) }
-      it { is_expected.to_not eq Appsignal::Utils::Data.generate({}) }
-
-      describe "#to_s" do
-        it "returns a serialized hash" do
-          expect(subject.to_s).to eq %({"":"test",) +
-            %("1":true,) +
-            %("bar":null,) +
-            %("baz":{"arr":[1,2],"foo":"bʊr"},) +
-            %("float":1.0,) +
-            %("foo":[1,2,"three",{"foo":"bar"}],) +
-            %("int":1,) +
-            %("int61":#{1 << 61},) +
-            %("int62":#{1 << 62},) +
-            %("int63":"bigint:#{1 << 63}",) +
-            %("int64":"bigint:#{1 << 64}",) +
-            %("the":"payload"})
+      context "with valid hash body" do
+        let(:body) { hash_body }
+
+        it "does not error and returns MockData class" do
+          expect(subject).to be_kind_of(Appsignal::Extension::MockData)
+          expect(subject.to_s).to eql("{}")
         end
       end
-    end
 
-    context "with a valid array body" do
-      let(:body) do
-        [
-          nil,
-          true,
-          false,
-          "string",
-          1, # Fixnum
-          1.0, # Float
-          1 << 61, # Fixnum
-          1 << 62, # Bignum, this one still works
-          1 << 63, # Bignum, turnover point for C, too big for long
-          1 << 64, # Bignum
-          { "arr" => [1, 2, "three"], "foo" => "bʊr" }
-        ]
+      context "with valid array body" do
+        let(:body) { array_body }
+
+        it "does not error and returns MockData class" do
+          expect(subject).to be_kind_of(Appsignal::Extension::MockData)
+          expect(subject.to_s).to eql("{}")
+        end
       end
 
-      it { is_expected.to eq Appsignal::Utils::Data.generate(body) }
-      it { is_expected.to_not eq Appsignal::Utils::Data.generate({}) }
-
-      describe "#to_s" do
-        it "returns a serialized array" do
-          expect(subject.to_s).to eq %([null,) +
-            %(true,) +
-            %(false,) +
-            %(\"string\",) +
-            %(1,) +
-            %(1.0,) +
-            %(#{1 << 61},) +
-            %(#{1 << 62},) +
-            %("bigint:#{1 << 63}",) +
-            %("bigint:#{1 << 64}",) +
-            %({\"arr\":[1,2,\"three\"],\"foo\":\"bʊr\"}])
+      context "with an invalid body" do
+        let(:body) { "body" }
+
+        it "raise a type error" do
+          expect do
+            subject
+          end.to raise_error TypeError
         end
       end
     end
 
-    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
-        {
-          "field_one" => [0x61, 0x61].pack("c*"),
-          :field_two => string_with_invalid_utf8,
-          "field_three" => [
-            "one", string_with_invalid_utf8
-          ],
-          "field_four" => {
-            "one" => string_with_invalid_utf8
-          }
-        }
+    context "when extension is loaded" do
+      context "with a valid hash body" do
+        let(:body) { hash_body }
+
+        it "returns a valid Data object" do
+          is_expected.to eq Appsignal::Utils::Data.generate(body)
+          is_expected.to_not eq Appsignal::Utils::Data.generate({})
+        end
+
+        describe "#to_s" do
+          it "returns a serialized hash" do
+            expect(subject.to_s).to eq %({"":"test",) +
+              %("1":true,) +
+              %("bar":null,) +
+              %("baz":{"arr":[1,2],"foo":"bʊr"},) +
+              %("float":1.0,) +
+              %("foo":[1,2,"three",{"foo":"bar"}],) +
+              %("int":1,) +
+              %("int61":#{1 << 61},) +
+              %("int62":#{1 << 62},) +
+              %("int63":"bigint:#{1 << 63}",) +
+              %("int64":"bigint:#{1 << 64}",) +
+              %("the":"payload"})
+          end
+        end
+      end
+
+      context "with a valid array body" do
+        let(:body) { array_body }
+
+        it "returns a valid Data object" do
+          is_expected.to eq Appsignal::Utils::Data.generate(body)
+          is_expected.to_not eq Appsignal::Utils::Data.generate({})
+        end
+
+        describe "#to_s" do
+          it "returns a serialized array" do
+            expect(subject.to_s).to eq %([null,) +
+              %(true,) +
+              %(false,) +
+              %(\"string\",) +
+              %(1,) +
+              %(1.0,) +
+              %(#{1 << 61},) +
+              %(#{1 << 62},) +
+              %("bigint:#{1 << 63}",) +
+              %("bigint:#{1 << 64}",) +
+              %({\"arr\":[1,2,\"three\"],\"foo\":\"bʊr\"}])
+          end
+        end
       end
 
-      describe "#to_s" do
-        it { expect(subject.to_s).to eq %({"field_four":{"one":"aa�"},"field_one":"aa","field_three":["one","aa�"],"field_two":"aa�"}) }
+      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
+          {
+            "field_one" => [0x61, 0x61].pack("c*"),
+            :field_two => string_with_invalid_utf8,
+            "field_three" => [
+              "one", string_with_invalid_utf8
+            ],
+            "field_four" => {
+              "one" => string_with_invalid_utf8
+            }
+          }
+        end
+
+        describe "#to_s" do
+          it "returns a JSON representation in a String" do
+            expect(subject.to_s).to eq %({"field_four":{"one":"aa�"},"field_one":"aa","field_three":["one","aa�"],"field_two":"aa�"})
+          end
+        end
       end
-    end
 
-    context "with an invalid body" do
-      let(:body) { "body" }
+      context "with an invalid body" do
+        let(:body) { "body" }
 
-      it "should raise a type error" do
-        expect do
-          subject
-        end.to raise_error TypeError
+        it "raises a type error" do
+          expect do
+            subject
+          end.to raise_error TypeError
+        end
       end
     end
   end
+
+  def hash_body
+    {
+      "the" => "payload",
+      "int" => 1, # Fixnum
+      "int61" => 1 << 61, # Fixnum
+      "int62" => 1 << 62, # Bignum, this one still works
+      "int63" => 1 << 63, # Bignum, turnover point for C, too big for long
+      "int64" => 1 << 64, # Bignum
+      "float" => 1.0,
+      1 => true,
+      nil => "test",
+      :foo => [1, 2, "three", { "foo" => "bar" }],
+      "bar" => nil,
+      "baz" => { "foo" => "bʊr", "arr" => [1, 2] }
+    }
+  end
+
+  def array_body
+    [
+      nil,
+      true,
+      false,
+      "string",
+      1, # Fixnum
+      1.0, # Float
+      1 << 61, # Fixnum
+      1 << 62, # Bignum, this one still works
+      1 << 63, # Bignum, turnover point for C, too big for long
+      1 << 64, # Bignum
+      { "arr" => [1, 2, "three"], "foo" => "bʊr" }
+    ]
+  end
 end

data/spec/lib/appsignal_spec.rb

@@ -686,6 +686,9 @@ describe Appsignal do
         )
       end
       let(:error) { ExampleException.new }
+      let(:err_stream) { std_stream }
+      let(:stderr) { err_stream.read }
+      around { |example| keep_transactions { example.run } }
 
       it "sends the error to AppSignal" do
         expect(Appsignal::Transaction).to receive(:new).with(
@@ -719,30 +722,60 @@ describe Appsignal do
 
       context "with tags" do
         let(:tags) { { :a => "a", :b => "b" } }
-        before do
-          allow(Appsignal::Transaction).to receive(:new).and_return(transaction)
-        end
 
-        it "tags the request before sending it" do
-          expect(transaction).to receive(:set_tags).with(tags).and_call_original
-          expect(transaction).to receive(:complete)
+        it "prints a deprecation warning and tags the transaction" do
+          logs = capture_logs do
+            expect do
+              capture_std_streams(std_stream, err_stream) do
+                Appsignal.send_error(error, tags)
+              end
+            end.to change { created_transactions.count }.by(1)
+          end
+
+          transaction = last_transaction
+          transaction_hash = transaction.to_h
+          expect(transaction_hash).to include(
+            "sample_data" => hash_including(
+              "tags" => { "a" => "a", "b" => "b" }
+            )
+          )
 
-          Appsignal.send_error(error, tags)
+          message = "The tags argument for `Appsignal.send_error` is deprecated. " \
+            "Please use the block method to set tags instead.\n\n" \
+            "  Appsignal.send_error(error) do |transaction|\n" \
+            "    transaction.set_tags(#{tags.inspect})\n" \
+            "  end\n\n" \
+            "Appsignal.send_error called on location: #{__FILE__}:"
+          expect(stderr).to include("appsignal WARNING: #{message}")
+          expect(logs).to include(message)
         end
       end
 
       context "with namespace" do
         let(:namespace) { "admin" }
 
-        it "sets the namespace on the transaction" do
-          expect(Appsignal::Transaction).to receive(:new).with(
-            kind_of(String),
-            "admin",
-            kind_of(Appsignal::Transaction::GenericRequest)
-          ).and_call_original
-        end
+        it "prints a deprecation warning and sets the namespace on the transaction" do
+          logs = capture_logs do
+            expect do
+              capture_std_streams(std_stream, err_stream) do
+                Appsignal.send_error(error, nil, namespace)
+              end
+            end.to change { created_transactions.count }.by(1)
+          end
+
+          transaction = last_transaction
+          transaction_hash = transaction.to_h
+          expect(transaction_hash).to include("namespace" => namespace)
 
-        after { Appsignal.send_error(error, nil, namespace) }
+          message = "The namespace argument for `Appsignal.send_error` is deprecated. " \
+            "Please use the block method to set the namespace instead.\n\n" \
+            "  Appsignal.send_error(error) do |transaction|\n" \
+            "    transaction.set_namespace(#{namespace.inspect})\n" \
+            "  end\n\n" \
+            "Appsignal.send_error called on location: #{__FILE__}:"
+          expect(stderr).to include("appsignal WARNING: #{message}")
+          expect(logs).to include(message)
+        end
       end
 
       context "when given a block" do
@@ -769,53 +802,85 @@ describe Appsignal do
     end
 
     describe ".listen_for_error" do
+      around { |example| keep_transactions { example.run } }
+
       it "records the error and re-raise it" do
-        expect(Appsignal).to receive(:send_error).with(
-          kind_of(ExampleException),
-          nil,
-          Appsignal::Transaction::HTTP_REQUEST
-        )
         expect do
-          Appsignal.listen_for_error do
-            raise ExampleException, "I am an exception"
-          end
-        end.to raise_error(ExampleException, "I am an exception")
+          expect do
+            Appsignal.listen_for_error do
+              raise ExampleException, "I am an exception"
+            end
+          end.to raise_error(ExampleException, "I am an exception")
+        end.to change { created_transactions.count }.by(1)
+
+        expect(last_transaction.to_h).to include(
+          "error" => {
+            "name" => "ExampleException",
+            "message" => "I am an exception",
+            "backtrace" => kind_of(String)
+          },
+          "namespace" => Appsignal::Transaction::HTTP_REQUEST, # Default namespace
+          "sample_data" => hash_including(
+            "tags" => {}
+          )
+        )
       end
 
       context "with tags" do
         it "adds tags to the transaction" do
-          expect(Appsignal).to receive(:send_error).with(
-            kind_of(ExampleException),
-            { "foo" => "bar" },
-            Appsignal::Transaction::HTTP_REQUEST
-          )
           expect do
-            Appsignal.listen_for_error("foo" => "bar") do
-              raise ExampleException, "I am an exception"
-            end
-          end.to raise_error(ExampleException, "I am an exception")
+            expect do
+              Appsignal.listen_for_error("foo" => "bar") do
+                raise ExampleException, "I am an exception"
+              end
+            end.to raise_error(ExampleException, "I am an exception")
+          end.to change { created_transactions.count }.by(1)
+
+          expect(last_transaction.to_h).to include(
+            "error" => {
+              "name" => "ExampleException",
+              "message" => "I am an exception",
+              "backtrace" => kind_of(String)
+            },
+            "namespace" => Appsignal::Transaction::HTTP_REQUEST, # Default namespace
+            "sample_data" => hash_including(
+              "tags" => { "foo" => "bar" }
+            )
+          )
         end
       end
 
       context "with a custom namespace" do
         it "adds the namespace to the transaction" do
-          expect(Appsignal).to receive(:send_error).with(
-            kind_of(ExampleException),
-            nil,
-            "custom_namespace"
-          )
           expect do
-            Appsignal.listen_for_error(nil, "custom_namespace") do
-              raise ExampleException, "I am an exception"
-            end
-          end.to raise_error(ExampleException, "I am an exception")
+            expect do
+              Appsignal.listen_for_error(nil, "custom_namespace") do
+                raise ExampleException, "I am an exception"
+              end
+            end.to raise_error(ExampleException, "I am an exception")
+          end.to change { created_transactions.count }.by(1)
+
+          expect(last_transaction.to_h).to include(
+            "error" => {
+              "name" => "ExampleException",
+              "message" => "I am an exception",
+              "backtrace" => kind_of(String)
+            },
+            "namespace" => "custom_namespace",
+            "sample_data" => hash_including(
+              "tags" => {}
+            )
+          )
         end
       end
     end
 
     describe ".set_error" do
+      let(:err_stream) { std_stream }
+      let(:stderr) { err_stream.read }
+      let(:error) { ExampleException.new("I am an exception") }
       before { allow(Appsignal::Transaction).to receive(:current).and_return(transaction) }
-      let(:error) { RuntimeError.new("I am an exception") }
+      around { |example| keep_transactions { example.run } }
 
       context "when there is an active transaction" do
         it "adds the error to the active transaction" do
@@ -845,24 +910,74 @@ describe Appsignal do
         context "with tags" do
           let(:tags) { { "foo" => "bar" } }
 
-          it "sets the tags on the transaction" do
+          it "prints a deprecation warning and tags the transaction" do
             expect(transaction).to receive(:set_error).with(error)
             expect(transaction).to receive(:set_tags).with(tags)
             expect(transaction).to_not receive(:set_namespace)
 
-            Appsignal.set_error(error, tags)
+            logs = capture_logs do
+              capture_std_streams(std_stream, err_stream) do
+                Appsignal.set_error(error, tags)
+              end
+            end
+
+            message = "The tags argument for `Appsignal.set_error` is deprecated. " \
+              "Please use the block method to set tags instead.\n\n" \
+              "  Appsignal.set_error(error) do |transaction|\n" \
+              "    transaction.set_tags(#{tags.inspect})\n" \
+              "  end\n\n" \
+              "Appsignal.set_error called on location: #{__FILE__}:"
+            expect(stderr).to include("appsignal WARNING: #{message}")
+            expect(logs).to include(message)
           end
         end
 
         context "with namespace" do
           let(:namespace) { "admin" }
 
-          it "sets the namespace on the transaction" do
+          it "prints a deprecation warning andsets the namespace on the transaction" do
             expect(transaction).to receive(:set_error).with(error)
             expect(transaction).to_not receive(:set_tags)
             expect(transaction).to receive(:set_namespace).with(namespace)
 
-            Appsignal.set_error(error, nil, namespace)
+            logs = capture_logs do
+              capture_std_streams(std_stream, err_stream) do
+                Appsignal.set_error(error, nil, namespace)
+              end
+            end
+
+            message = "The namespace argument for `Appsignal.set_error` is deprecated. " \
+              "Please use the block method to set the namespace instead.\n\n" \
+              "  Appsignal.set_error(error) do |transaction|\n" \
+              "    transaction.set_namespace(#{namespace.inspect})\n" \
+              "  end\n\n" \
+              "Appsignal.set_error called on location: #{__FILE__}:"
+            expect(stderr).to include("appsignal WARNING: #{message}")
+            expect(logs).to include(message)
+          end
+        end
+
+        context "when given a block" do
+          it "yields the transaction and allows additional metadata to be set" do
+            captured_transaction = nil
+            keep_transactions do
+              Appsignal.set_error(StandardError.new("my_error")) do |transaction|
+                captured_transaction = transaction
+                transaction.set_action("my_action")
+                transaction.set_namespace("my_namespace")
+              end
+            end
+
+            expect(transaction).to eql(captured_transaction)
+            expect(captured_transaction.to_h).to include(
+              "namespace" => "my_namespace",
+              "action" => "my_action",
+              "error" => {
+                "name" => "StandardError",
+                "message" => "my_error",
+                "backtrace" => kind_of(String)
+              }
+            )
           end
         end
       end