appsignal 2.11.1-java → 3.0.0.beta.1-java

data/spec/lib/appsignal/hooks/sidekiq_spec.rb

@@ -262,7 +262,8 @@ describe Appsignal::Hooks::SidekiqPlugin, :with_yaml_parse_error => false do
         "sample_data" => {
           "environment" => {},
           "params" => expected_args,
-          "tags" => {}
+          "tags" => {},
+          "breadcrumbs" => []
         }
       )
       expect_transaction_to_have_sidekiq_event(transaction_hash)
@@ -290,7 +291,8 @@ describe Appsignal::Hooks::SidekiqPlugin, :with_yaml_parse_error => false do
         "sample_data" => {
           "environment" => {},
           "params" => expected_args,
-          "tags" => {}
+          "tags" => {},
+          "breadcrumbs" => []
         }
       )
       # TODO: Not available in transaction.to_h yet.

data/spec/lib/appsignal/hooks/unicorn_spec.rb

@@ -3,12 +3,22 @@ describe Appsignal::Hooks::UnicornHook do
     before :context do
       module Unicorn
         class HttpServer
-          def worker_loop(worker)
+          def worker_loop(_worker)
+            @worker_loop = true
+          end
+
+          def worker_loop?
+            @worker_loop == true
           end
         end
 
         class Worker
           def close
+            @close = true
+          end
+
+          def close?
+            @close == true
           end
         end
       end
@@ -27,18 +37,19 @@ describe Appsignal::Hooks::UnicornHook do
       worker = double
 
       expect(Appsignal).to receive(:forked)
-      expect(server).to receive(:worker_loop_without_appsignal).with(worker)
 
       server.worker_loop(worker)
+
+      expect(server.worker_loop?).to be true
     end
 
     it "adds behavior to Unicorn::Worker#close" do
       worker = Unicorn::Worker.new
 
       expect(Appsignal).to receive(:stop)
-      expect(worker).to receive(:close_without_appsignal)
 
       worker.close
+      expect(worker.close?).to be true
     end
   end
 

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

@@ -10,19 +10,8 @@ describe Appsignal::Hooks::WebmachineHook do
         it { is_expected.to be_truthy }
       end
 
-      it "should include the run alias methods" do
-        expect(fsm).to respond_to(:run_with_appsignal)
-        expect(fsm).to respond_to(:run_without_appsignal)
-      end
-
-      it "should include the handle_exceptions alias methods" do
-        expect(
-          fsm.respond_to?(:handle_exceptions_with_appsignal, true)
-        ).to be_truthy
-
-        expect(
-          fsm.respond_to?(:handle_exceptions_without_appsignal, true)
-        ).to be_truthy
+      it "adds behavior to Webmachine::Decision::FSM" do
+        expect(fsm.class.ancestors.first).to eq(Appsignal::Integrations::WebmachineIntegration)
       end
     end
   else

data/spec/lib/appsignal/hooks_spec.rb

@@ -78,63 +78,6 @@ describe Appsignal::Hooks do
     expect(Appsignal::Hooks.hooks[:mock_error_hook].installed?).to be_falsy
     Appsignal::Hooks.hooks.delete(:mock_error_hook)
   end
-
-  describe "missing constants" do
-    let(:err_stream) { std_stream }
-    let(:stderr) { err_stream.read }
-    let(:log_stream) { std_stream }
-    let(:log) { log_contents(log_stream) }
-    before do
-      Appsignal.logger = test_logger(log_stream)
-    end
-
-    def call_constant(&block)
-      capture_std_streams(std_stream, err_stream, &block)
-    end
-
-    describe "SidekiqProbe" do
-      it "logs a deprecation message and returns the new constant" do
-        constant = call_constant { Appsignal::Hooks::SidekiqProbe }
-
-        expect(constant).to eql(Appsignal::Probes::SidekiqProbe)
-        expect(constant.name).to eql("Appsignal::Probes::SidekiqProbe")
-
-        deprecation_message =
-          "The constant Appsignal::Hooks::SidekiqProbe has been deprecated. " \
-          "Please update the constant name to Appsignal::Probes::SidekiqProbe " \
-          "in the following file to remove this message.\n#{__FILE__}:"
-        expect(stderr).to include "appsignal WARNING: #{deprecation_message}"
-        expect(log).to contains_log :warn, deprecation_message
-      end
-    end
-
-    describe "PumaProbe" do
-      it "logs a deprecation message and returns the new constant" do
-        constant = call_constant { Appsignal::Hooks::PumaProbe }
-
-        expect(constant).to eql(Appsignal::Probes::PumaProbe)
-        expect(constant.name).to eql("Appsignal::Probes::PumaProbe")
-
-        deprecation_message =
-          "The constant Appsignal::Hooks::PumaProbe has been deprecated. " \
-          "Please update the constant name to Appsignal::Probes::PumaProbe " \
-          "in the following file to remove this message.\n#{__FILE__}:"
-        expect(stderr).to include "appsignal WARNING: #{deprecation_message}"
-        expect(log).to contains_log :warn, deprecation_message
-      end
-    end
-
-    describe "other constant" do
-      it "raises a NameError like Ruby normally does" do
-        expect do
-          call_constant { Appsignal::Hooks::Unknown }
-        end.to raise_error(NameError)
-
-        expect(stderr).to be_empty
-        expect(log).to be_empty
-      end
-    end
-  end
 end
 
 describe Appsignal::Hooks::Helpers do

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

@@ -5,14 +5,22 @@ describe Object do
     context "with instance method" do
       let(:klass) do
         Class.new do
-          def foo
-            1
+          def foo(param1, options = {}, keyword_param: 1)
+            [param1, options, keyword_param]
           end
           appsignal_instrument_method :foo
         end
       end
       let(:instance) { klass.new }
 
+      def call_with_arguments
+        instance.foo(
+          "abc",
+          { :foo => "bar" },
+          :keyword_param => 2
+        )
+      end
+
       context "when active" do
         let(:transaction) { http_request_transaction }
         before do
@@ -27,7 +35,7 @@ describe Object do
             expect(transaction).to receive(:start_event)
             expect(transaction).to receive(:finish_event).with \
               "foo.AnonymousClass.other", nil, nil, Appsignal::EventFormatter::DEFAULT
-            expect(instance.foo).to eq(1)
+            expect(call_with_arguments).to eq(["abc", { :foo => "bar" }, 2])
           end
         end
 
@@ -116,10 +124,10 @@ describe Object do
       context "when not active" do
         let(:transaction) { Appsignal::Transaction.current }
 
-        it "should not instrument, but still call the method" do
+        it "does not instrument, but still calls the method" do
           expect(Appsignal.active?).to be_falsy
           expect(transaction).to_not receive(:start_event)
-          expect(instance.foo).to eq(1)
+          expect(call_with_arguments).to eq(["abc", { :foo => "bar" }, 2])
         end
       end
     end
@@ -127,12 +135,19 @@ describe Object do
     context "with class method" do
       let(:klass) do
         Class.new do
-          def self.bar
-            2
+          def self.bar(param1, options = {}, keyword_param: 1)
+            [param1, options, keyword_param]
           end
           appsignal_instrument_class_method :bar
         end
       end
+      def call_with_arguments
+        klass.bar(
+          "abc",
+          { :foo => "bar" },
+          :keyword_param => 2
+        )
+      end
 
       context "when active" do
         let(:transaction) { http_request_transaction }
@@ -149,7 +164,7 @@ describe Object do
             expect(transaction).to receive(:start_event)
             expect(transaction).to receive(:finish_event).with \
               "bar.class_method.AnonymousClass.other", nil, nil, Appsignal::EventFormatter::DEFAULT
-            expect(klass.bar).to eq(2)
+            expect(call_with_arguments).to eq(["abc", { :foo => "bar" }, 2])
           end
         end
 
@@ -238,10 +253,10 @@ describe Object do
       context "when not active" do
         let(:transaction) { Appsignal::Transaction.current }
 
-        it "should not instrument, but still call the method" do
+        it "does not instrument, but still call the method" do
           expect(Appsignal.active?).to be_falsy
           expect(transaction).to_not receive(:start_event)
-          expect(klass.bar).to eq(2)
+          expect(call_with_arguments).to eq(["abc", { :foo => "bar" }, 2])
         end
       end
     end

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

@@ -150,10 +150,9 @@ if DependencyHelper.padrino_present?
             let(:path) { "/static" }
             before do
               env["sinatra.static_file"] = true
-              expect_any_instance_of(app)
-                .to receive(:route_without_appsignal).and_return([200, {}, ["foo"]])
+              app.controllers { get(:static) { "Static!" } }
             end
-            after { expect(response).to match_response(200, "foo") }
+            after { expect(response).to match_response(200, "Static!") }
 
             it "does not instrument the request" do
               expect_no_transaction_to_be_created

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

@@ -79,51 +79,6 @@ if DependencyHelper.rails_present?
 
         after { Appsignal::Integrations::Railtie.initialize_appsignal(app) }
       end
-
-      describe "frontend_error_catching middleware" do
-        let(:config) do
-          Appsignal::Config.new(
-            project_fixture_path,
-            "test",
-            :name => "MyApp",
-            :enable_frontend_error_catching => enable_frontend_error_catching
-          )
-        end
-        before { allow(Appsignal::Config).to receive(:new).and_return(config) }
-        after { Appsignal::Integrations::Railtie.initialize_appsignal(app) }
-
-        context "when enabled" do
-          let(:enable_frontend_error_catching) { true }
-
-          it "adds the Rails and JSExceptionCatcher middleware" do
-            expect(app.middleware).to receive(:insert_after).with(
-              ActionDispatch::DebugExceptions,
-              Appsignal::Rack::RailsInstrumentation
-            )
-
-            expect(app.middleware).to receive(:insert_before).with(
-              Appsignal::Rack::RailsInstrumentation,
-              Appsignal::Rack::JSExceptionCatcher
-            )
-          end
-        end
-
-        context "when not enabled" do
-          let(:enable_frontend_error_catching) { false }
-
-          it "adds the Rails middleware, but not the JSExceptionCatcher middleware" do
-            expect(app.middleware).to receive(:insert_after).with(
-              ActionDispatch::DebugExceptions,
-              Appsignal::Rack::RailsInstrumentation
-            )
-
-            expect(app.middleware).to_not receive(:insert_before).with(
-              Appsignal::Rack::RailsInstrumentation,
-              Appsignal::Rack::JSExceptionCatcher
-            )
-          end
-        end
-      end
     end
   end
 end

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

@@ -356,6 +356,57 @@ describe Appsignal::Transaction do
       end
     end
 
+    describe "#add_breadcrumb" do
+      context "when over the limit" do
+        before do
+          22.times do |i|
+            transaction.add_breadcrumb(
+              "network",
+              "GET http://localhost",
+              "User made external network request",
+              { :code => i + 1 },
+              Time.parse("10-10-2010 10:00:00 UTC")
+            )
+          end
+          transaction.sample_data
+        end
+
+        it "stores last <LIMIT> breadcrumbs on the transaction" do
+          expect(transaction.to_h["sample_data"]["breadcrumbs"].length).to eql(20)
+          expect(transaction.to_h["sample_data"]["breadcrumbs"][0]).to eq(
+            "action" => "GET http://localhost",
+            "category" => "network",
+            "message" => "User made external network request",
+            "metadata" => { "code" => 3 },
+            "time" => 1286704800 # rubocop:disable Style/NumericLiterals
+          )
+          expect(transaction.to_h["sample_data"]["breadcrumbs"][19]).to eq(
+            "action" => "GET http://localhost",
+            "category" => "network",
+            "message" => "User made external network request",
+            "metadata" => { "code" => 22 },
+            "time" => 1286704800 # rubocop:disable Style/NumericLiterals
+          )
+        end
+      end
+
+      context "with defaults" do
+        it "stores breadcrumb with defaults on transaction" do
+          timeframe_start = Time.now.utc.to_i
+          transaction.add_breadcrumb("user_action", "clicked HOME")
+          transaction.sample_data
+          timeframe_end = Time.now.utc.to_i
+
+          breadcrumb = transaction.to_h["sample_data"]["breadcrumbs"][0]
+          expect(breadcrumb["category"]).to eq("user_action")
+          expect(breadcrumb["action"]).to eq("clicked HOME")
+          expect(breadcrumb["message"]).to eq("")
+          expect(breadcrumb["time"]).to be_between(timeframe_start, timeframe_end)
+          expect(breadcrumb["metadata"]).to eq({})
+        end
+      end
+    end
+
     describe "#set_action" do
       context "when the action is set" do
         it "updates the action name on the transaction" do
@@ -589,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
@@ -601,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
 
@@ -649,6 +687,10 @@ describe Appsignal::Transaction do
           "tags",
           Appsignal::Utils::Data.generate({})
         ).once
+        expect(transaction.ext).to receive(:set_sample_data).with(
+          "breadcrumbs",
+          Appsignal::Utils::Data.generate([])
+        ).once
 
         transaction.sample_data
       end