appsignal 2.11.8-java → 3.0.1-java

data/spec/lib/appsignal/integrations/webmachine_spec.rb

@@ -1,12 +1,24 @@
 if DependencyHelper.webmachine_present?
   require "appsignal/integrations/webmachine"
 
-  describe Appsignal::Integrations::WebmachinePlugin::FSM do
+  class Response
+    attr_accessor :code
+
+    def body
+      ""
+    end
+
+    def headers
+      {}
+    end
+  end
+
+  describe Appsignal::Integrations::WebmachineIntegration do
     let(:request) do
       Webmachine::Request.new("GET", "http://google.com:80/foo", {}, nil)
     end
-    let(:resource)    { double(:trace? => false, :handle_exception => true) }
-    let(:response)    { double }
+    let(:resource)    { double(:trace? => false, :handle_exception => true, :"code=" => nil) }
+    let(:response)    { Response.new }
     let(:transaction) { double(:set_action_if_nil => true) }
     let(:fsm) { Webmachine::Decision::FSM.new(resource, request, response) }
     before(:context) { start_agent }
@@ -18,10 +30,8 @@ if DependencyHelper.webmachine_present?
       end
     end
 
-    describe "#run_with_appsignal" do
+    describe "#run" do
       before do
-        allow(fsm).to receive(:request).and_return(request)
-        allow(fsm).to receive(:run_without_appsignal).and_return(true)
         allow(SecureRandom).to receive(:uuid).and_return("uuid")
         allow(Appsignal::Transaction).to receive(:create).and_return(transaction)
       end
@@ -40,7 +50,7 @@ if DependencyHelper.webmachine_present?
       end
 
       it "should call the original method" do
-        expect(fsm).to receive(:run_without_appsignal)
+        expect(fsm).to receive(:run)
       end
 
       it "should instrument the original method" do
@@ -52,9 +62,17 @@ if DependencyHelper.webmachine_present?
       end
 
       after { fsm.run }
+
+      describe "concerning the response" do
+        it "sets a response code" do
+          expect(fsm.response.code).to be_nil
+          fsm.run
+          expect(fsm.response.code).not_to be_nil
+        end
+      end
     end
 
-    describe "#handle_exceptions_with_appsignal" do
+    describe "#handle_exceptions" do
       let(:error) { ExampleException }
 
       it "should catch the error and send it to AppSignal" do

data/spec/lib/appsignal/minutely_spec.rb

@@ -284,25 +284,6 @@ describe Appsignal::Minutely do
       end
     end
 
-    describe "#<<" do
-      let(:err_stream) { std_stream }
-      let(:stderr) { err_stream.read }
-      let(:log_stream) { std_stream }
-      let(:log) { log_contents(log_stream) }
-      before { Appsignal.logger = test_logger(log_stream) }
-
-      it "adds the probe, but prints a deprecation warning" do
-        probe = lambda {}
-        capture_std_streams(std_stream, err_stream) { collection << probe }
-        deprecation_message = "Deprecated " \
-          "`Appsignal::Minute.probes <<` call. Please use " \
-          "`Appsignal::Minutely.probes.register` instead."
-        expect(stderr).to include "appsignal WARNING: #{deprecation_message}"
-        expect(log).to contains_log :warn, deprecation_message
-        expect(collection[probe.object_id]).to eql(probe)
-      end
-    end
-
     describe "#register" do
       let(:log_stream) { std_stream }
       let(:log) { log_contents(log_stream) }

data/spec/lib/appsignal/transaction_spec.rb

@@ -640,7 +640,7 @@ describe Appsignal::Transaction do
       end
 
       context "when the data cannot be converted to JSON" do
-        it "does not update the sample data on the transaction", :not_ruby19 do
+        it "does not update the sample data on the transaction" do
           klass = Class.new do
             def to_s
               raise "foo" # Cause a deliberate error
@@ -652,19 +652,6 @@ describe Appsignal::Transaction do
           expect(log_contents(log)).to contains_log :error,
             "Error generating data (RuntimeError: foo) for"
         end
-
-        it "does not update the sample data on the transaction", :only_ruby19 do
-          klass = Class.new do
-            def to_s
-              raise "foo" # Cause a deliberate error
-            end
-          end
-          transaction.set_sample_data("params", klass.new => 1)
-
-          expect(transaction.to_h["sample_data"]).to eq({})
-          expect(log_contents(log)).to contains_log :error,
-            "Error generating data (RuntimeError: foo). Can't inspect data."
-        end
       end
     end
 

data/spec/lib/appsignal/transmitter_spec.rb

@@ -143,7 +143,7 @@ describe Appsignal::Transmitter do
     context "with a proxy" do
       let(:config) { project_fixture_config("production", :http_proxy => "http://localhost:8080") }
 
-      it "is of Net::HTTP class", :not_ruby19 do
+      it "is of Net::HTTP class" do
         expect(subject).to be_instance_of(Net::HTTP)
       end
       it { expect(subject.proxy?).to be_truthy }

data/spec/lib/appsignal_spec.rb

@@ -63,11 +63,6 @@ describe Appsignal do
         Appsignal.start
       end
 
-      it "should load deprecated event formatters" do
-        expect(Appsignal::EventFormatter).to receive(:initialize_deprecated_formatters)
-        Appsignal.start
-      end
-
       context "with an extension" do
         before { Appsignal.extensions << Appsignal::MockExtension }
 
@@ -691,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(
@@ -724,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.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
@@ -774,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
@@ -850,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.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
@@ -980,70 +1090,6 @@ describe Appsignal do
         end
       end
     end
-
-    describe ".is_ignored_error?" do
-      let(:error) { StandardError.new }
-      let(:err_stream) { std_stream }
-      let(:stderr) { err_stream.read }
-      before do
-        allow(Appsignal).to receive(:config).and_return(:ignore_errors => ["StandardError"])
-      end
-
-      subject do
-        capture_std_streams(std_stream, err_stream) do
-          Appsignal.is_ignored_error?(error)
-        end
-      end
-
-      it "should return true if it's in the ignored list" do
-        is_expected.to be_truthy
-      end
-
-      it "outputs deprecated warning" do
-        subject
-        expect(stderr).to include("Appsignal.is_ignored_error? is deprecated with no replacement")
-      end
-
-      context "when error is not in the ignored list" do
-        let(:error) { Object.new }
-
-        it "should return false" do
-          is_expected.to be_falsy
-        end
-      end
-    end
-
-    describe ".is_ignored_action?" do
-      let(:action) { "TestController#isup" }
-      let(:err_stream) { std_stream }
-      let(:stderr) { err_stream.read }
-      before do
-        allow(Appsignal).to receive(:config).and_return(:ignore_actions => "TestController#isup")
-      end
-
-      subject do
-        capture_std_streams(std_stream, err_stream) do
-          Appsignal.is_ignored_action?(action)
-        end
-      end
-
-      it "should return true if it's in the ignored list" do
-        is_expected.to be_truthy
-      end
-
-      it "outputs deprecated warning" do
-        subject
-        expect(stderr).to include("Appsignal.is_ignored_action? is deprecated with no replacement")
-      end
-
-      context "when action is not in the ingore list" do
-        let(:action) { "TestController#other_action" }
-
-        it "should return false" do
-          is_expected.to be_falsy
-        end
-      end
-    end
   end
 
   describe ".start_logger" do