appsignal 3.11.0 → 3.12.1

data/spec/lib/appsignal/probes_spec.rb

@@ -408,13 +408,14 @@ describe Appsignal::Probes do
       end
 
       context "logger" do
-        let(:log_stream) { std_stream }
-        let(:log) { log_contents(log_stream) }
+        before { start_agent }
 
-        around { |example| use_logger_with(log_stream) { example.run } }
         it "logs a deprecation message" do
-          silence { collection.register :my_probe, lambda {} }
-          expect(log).to contains_log :warn,
+          logs =
+            capture_logs do
+              silence { collection.register :my_probe, lambda {} }
+            end
+          expect(logs).to contains_log :warn,
             "The method 'Appsignal::Probes.probes.register' is deprecated. " \
               "Use 'Appsignal::Probes.register' instead."
         end

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

@@ -12,7 +12,7 @@ describe Appsignal::Rack::AbstractMiddleware do
   let(:options) { {} }
   let(:middleware) { described_class.new(app, options) }
 
-  before(:context) { start_agent }
+  before { start_agent }
   around { |example| keep_transactions { example.run } }
 
   def make_request
@@ -400,11 +400,12 @@ describe Appsignal::Rack::AbstractMiddleware do
           expect(response_events).to eq(1)
         end
 
-        context "when response body is already a BodyWrapper subclass" do
+        context "when the response body is already instrumented" do
           let(:body) { Appsignal::Rack::BodyWrapper.wrap(["hello!"], transaction) }
           let(:app) { DummyApp.new { [200, {}, body] } }
 
           it "doesn't wrap the body again" do
+            env[Appsignal::Rack::APPSIGNAL_RESPONSE_INSTRUMENTED] = true
             _status, _headers, body = make_request
             expect(body).to eq(body)
 

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

@@ -40,6 +40,14 @@ describe Appsignal::Rack::EventHandler do
       expect(Appsignal::Transaction.current).to eq(transaction)
     end
 
+    context "when not active" do
+      it "does not create a new transaction" do
+        allow(Appsignal).to receive(:active?).and_return(false)
+
+        expect { on_start }.to_not(change { created_transactions.length })
+      end
+    end
+
     context "when the handler is nested in another EventHandler" do
       it "does not create a new transaction in the nested EventHandler" do
         on_start
@@ -131,6 +139,17 @@ describe Appsignal::Rack::EventHandler do
       expect(last_transaction).to have_error("ExampleStandardError", "the error")
     end
 
+    context "when not active" do
+      it "does not report the transaction" do
+        allow(Appsignal).to receive(:active?).and_return(false)
+
+        on_start
+        on_error(ExampleStandardError.new("the error"))
+
+        expect(last_transaction).to_not have_error
+      end
+    end
+
     context "when the handler is nested in another EventHandler" do
       it "does not report the error on the transaction" do
         on_start
@@ -175,6 +194,20 @@ describe Appsignal::Rack::EventHandler do
       expect(last_transaction).to_not be_completed
     end
 
+    context "when not active" do
+      it "doesn't do anything" do
+        allow(Appsignal).to receive(:active?).and_return(false)
+
+        request.env[Appsignal::Rack::APPSIGNAL_TRANSACTION] = http_request_transaction
+        on_finish
+
+        expect(last_transaction).to_not have_action
+        expect(last_transaction).to_not include_events
+        expect(last_transaction).to include("sample_data" => {})
+        expect(last_transaction).to_not be_completed
+      end
+    end
+
     it "sets params on the transaction" do
       on_start
       on_finish

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

@@ -46,7 +46,7 @@ describe "Appsignal::Rack::GenericInstrumentation" do
     let(:env) { Rack::MockRequest.env_for("/some/path") }
     let(:middleware) { Appsignal::Rack::GenericInstrumentation.new(app, {}) }
 
-    before(:context) { start_agent }
+    before { start_agent }
     around { |example| keep_transactions { example.run } }
 
     def make_request(env)

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

@@ -1,38 +1,5 @@
 if DependencyHelper.grape_present?
-  require "appsignal/integrations/grape"
-
-  context "Appsignal::Grape::Middleware constant" do
-    let(:err_stream) { std_stream }
-    let(:stderr) { err_stream.read }
-
-    it "returns the Rack::GrapeMiddleware constant calling the Grape::Middleware constant" do
-      silence { expect(Appsignal::Grape::Middleware).to be(Appsignal::Rack::GrapeMiddleware) }
-    end
-
-    it "prints a deprecation warning to STDERR" do
-      capture_std_streams(std_stream, err_stream) do
-        expect(Appsignal::Grape::Middleware).to be(Appsignal::Rack::GrapeMiddleware)
-      end
-
-      expect(stderr).to include(
-        "appsignal WARNING: The constant Appsignal::Grape::Middleware has been deprecated."
-      )
-    end
-
-    it "logs a warning" do
-      logs =
-        capture_logs do
-          silence do
-            expect(Appsignal::Grape::Middleware).to be(Appsignal::Rack::GrapeMiddleware)
-          end
-        end
-
-      expect(logs).to contains_log(
-        :warn,
-        "The constant Appsignal::Grape::Middleware has been deprecated."
-      )
-    end
-  end
+  require "appsignal/rack/grape_middleware"
 
   describe Appsignal::Rack::GrapeMiddleware do
     let(:app) do
@@ -52,7 +19,7 @@ if DependencyHelper.grape_present?
     end
     let(:middleware) { Appsignal::Rack::GrapeMiddleware.new(api_endpoint) }
     let(:transaction) { http_request_transaction }
-    before(:context) { start_agent }
+    before { start_agent }
     around do |example|
       GrapeExample = Module.new
       GrapeExample.send(:const_set, :Api, app)

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

@@ -12,7 +12,7 @@ if DependencyHelper.hanami2_present?
     end
     let(:middleware) { Appsignal::Rack::HanamiMiddleware.new(app, {}) }
 
-    before(:context) { start_agent }
+    before { start_agent }
     around { |example| keep_transactions { example.run } }
 
     def make_request(env)

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

@@ -1,5 +1,5 @@
 if DependencyHelper.sinatra_present?
-  require "appsignal/integrations/sinatra"
+  require "appsignal/rack/sinatra_instrumentation"
 
   module SinatraRequestHelpers
     def make_request
@@ -21,7 +21,7 @@ if DependencyHelper.sinatra_present?
     end
     let(:middleware) { Appsignal::Rack::SinatraInstrumentation.new(app) }
 
-    before(:context) { start_agent }
+    before { start_agent }
     around do |example|
       keep_transactions { example.run }
     end
@@ -54,7 +54,7 @@ if DependencyHelper.sinatra_present?
     let(:options) { {} }
     let(:middleware) { Appsignal::Rack::SinatraBaseInstrumentation.new(app, options) }
 
-    before(:context) { start_agent }
+    before { start_agent }
     around do |example|
       keep_transactions { example.run }
     end

data/spec/lib/appsignal/span_spec.rb

@@ -1,9 +1,7 @@
 require "appsignal/span"
 
 describe Appsignal::Span do
-  before :context do
-    start_agent
-  end
+  before { start_agent }
 
   let(:namespace) { "web" }
   let(:root) { Appsignal::Span.new(namespace) }

data/spec/lib/appsignal/transaction_spec.rb

@@ -1,10 +1,12 @@
 describe Appsignal::Transaction do
   let(:time) { Time.at(fixed_time) }
 
-  before { Timecop.freeze(time) }
+  before do
+    start_agent
+    Timecop.freeze(time)
+  end
   after { Timecop.return }
   around do |example|
-    start_agent
     keep_transactions do
       example.run
     end
@@ -1497,54 +1499,53 @@ describe Appsignal::Transaction do
   describe "#set_error" do
     let(:transaction) { new_transaction }
     let(:env) { http_request_env_with_data }
-    let(:error) do
-      e = ExampleStandardError.new("test message")
-      allow(e).to receive(:backtrace).and_return(["line 1"])
-      e
-    end
+    let(:error) { ExampleStandardError.new("test message") }
 
-    it "should also respond to add_exception for backwards compatibility" do
+    it "responds to add_exception for backwards compatibility" do
       expect(transaction).to respond_to(:add_exception)
     end
 
-    it "should not add the error if appsignal is not active" do
+    it "does not add the error if not active" do
       allow(Appsignal).to receive(:active?).and_return(false)
-      expect(transaction.ext).to_not receive(:set_error)
 
       transaction.set_error(error)
+
+      expect(transaction).to_not have_error
     end
 
-    context "when error is not an error" do
+    context "when error argument is not an error" do
       let(:error) { Object.new }
 
       it "does not add the error" do
-        expect(Appsignal.internal_logger).to receive(:error).with(
+        logs = capture_logs { transaction.set_error(error) }
+
+        expect(transaction).to_not have_error
+        expect(logs).to contains_log(
+          :error,
           "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(
+      it "sets an error on the transaction" do
+        allow(error).to receive(:backtrace).and_return(["line 1"])
+        transaction.set_error(error)
+
+        expect(transaction).to have_error(
           "ExampleStandardError",
           "test message",
-          Appsignal::Utils::Data.generate(["line 1"])
+          ["line 1"]
         )
-
-        transaction.set_error(error)
       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)
-
+      it "does not set the causes information as sample data" do
         transaction.set_error(error)
+
+        expect(transaction).to_not include_error_causes
       end
     end
 
@@ -1560,31 +1561,25 @@ describe Appsignal::Transaction do
       end
 
       it "sends the causes information as sample data" do
-        expect(transaction.ext).to receive(:set_error).with(
+        transaction.set_error(error)
+
+        expect(transaction).to have_error(
           "ExampleStandardError",
           "test message",
-          Appsignal::Utils::Data.generate(["line 1"])
+          ["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(transaction).to include_error_causes(
+          [
+            {
+              "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
 
@@ -1603,33 +1598,29 @@ describe Appsignal::Transaction do
       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 =
+          Array.new(10) do |i|
+            {
+              "name" => "ExampleStandardError",
+              "message" => "wrapper error #{9 - i}"
+            }
+          end
+        expected_error_causes.last["is_root_cause"] = false
 
-        expected_error_causes.last[:is_root_cause] = false
+        logs = capture_logs { transaction.set_error(error) }
 
-        expect(transaction.ext).to receive(:set_sample_data).with(
-          "error_causes",
-          Appsignal::Utils::Data.generate(expected_error_causes)
+        expect(transaction).to have_error(
+          "ExampleStandardError",
+          "wrapper error 10",
+          ["line 1"]
         )
-
-        expect(Appsignal.internal_logger).to receive(:debug).with(
+        expect(transaction).to include_error_causes(expected_error_causes)
+        expect(logs).to contains_log(
+          :debug,
           "Appsignal::Transaction#set_error: Error has more " \
             "than 10 error causes. Only the first 10 " \
             "will be reported."
         )
-
-        transaction.set_error(error)
       end
     end
 
@@ -1641,18 +1632,18 @@ describe Appsignal::Transaction do
         e
       end
 
-      it "should not raise an error" do
+      it "does not raise an error" do
         transaction.set_error(error)
       end
 
-      it "should set an error in the extension" do
-        expect(transaction.ext).to receive(:set_error).with(
+      it "sets an error on the transaction without an error message" do
+        transaction.set_error(error)
+
+        expect(transaction).to have_error(
           "ExampleStandardError",
           "",
-          Appsignal::Utils::Data.generate(["line 1"])
+          ["line 1"]
         )
-
-        transaction.set_error(error)
       end
     end
   end