appsignal 3.13.1 → 4.0.0.beta.1

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

@@ -1,7 +1,11 @@
 require "appsignal/integrations/sidekiq"
 
 describe Appsignal::Integrations::SidekiqDeathHandler do
-  before { start_agent }
+  let(:options) { {} }
+  before do
+    stub_const("Sidekiq::VERSION", "7.1.0")
+    start_agent(:options => options)
+  end
   around { |example| keep_transactions { example.run } }
 
   let(:exception) do
@@ -28,10 +32,8 @@ describe Appsignal::Integrations::SidekiqDeathHandler do
   end
 
   context "when sidekiq_report_errors = none" do
-    before do
-      Appsignal.config[:sidekiq_report_errors] = "none"
-      call_handler
-    end
+    let(:options) { { :sidekiq_report_errors => "none" } }
+    before { call_handler }
 
     it "doesn't track the error on the transaction" do
       expect_no_error_on_transaction
@@ -39,10 +41,8 @@ describe Appsignal::Integrations::SidekiqDeathHandler do
   end
 
   context "when sidekiq_report_errors = all" do
-    before do
-      Appsignal.config[:sidekiq_report_errors] = "all"
-      call_handler
-    end
+    let(:options) { { :sidekiq_report_errors => "all" } }
+    before { call_handler }
 
     it "doesn't track the error on the transaction" do
       expect_no_error_on_transaction
@@ -50,10 +50,8 @@ describe Appsignal::Integrations::SidekiqDeathHandler do
   end
 
   context "when sidekiq_report_errors = discard" do
-    before do
-      Appsignal.config[:sidekiq_report_errors] = "discard"
-      call_handler
-    end
+    let(:options) { { :sidekiq_report_errors => "discard" } }
+    before { call_handler }
 
     it "records each occurrence of the error on the transaction" do
       expect_error_on_transaction
@@ -62,7 +60,8 @@ describe Appsignal::Integrations::SidekiqDeathHandler do
 end
 
 describe Appsignal::Integrations::SidekiqErrorHandler do
-  before { start_agent }
+  let(:options) { {} }
+  before { start_agent(:options => options) }
   around { |example| keep_transactions { example.run } }
 
   let(:exception) do
@@ -96,7 +95,7 @@ describe Appsignal::Integrations::SidekiqErrorHandler do
     end
 
     context "when sidekiq_report_errors = none" do
-      before { Appsignal.config[:sidekiq_report_errors] = "none" }
+      let(:options) { { :sidekiq_report_errors => "none" } }
 
       it "tracks the error on a new transaction" do
         expect_report_internal_error
@@ -104,7 +103,7 @@ describe Appsignal::Integrations::SidekiqErrorHandler do
     end
 
     context "when sidekiq_report_errors = all" do
-      before { Appsignal.config[:sidekiq_report_errors] = "all" }
+      let(:options) { { :sidekiq_report_errors => "all" } }
 
       it "tracks the error on a new transaction" do
         expect_report_internal_error
@@ -112,7 +111,7 @@ describe Appsignal::Integrations::SidekiqErrorHandler do
     end
 
     context "when sidekiq_report_errors = discard" do
-      before { Appsignal.config[:sidekiq_report_errors] = "discard" }
+      let(:options) { { :sidekiq_report_errors => "discard" } }
 
       it "tracks the error on a new transaction" do
         expect_report_internal_error
@@ -143,10 +142,8 @@ describe Appsignal::Integrations::SidekiqErrorHandler do
     end
 
     context "when sidekiq_report_errors = none" do
-      before do
-        Appsignal.config[:sidekiq_report_errors] = "none"
-        call_handler
-      end
+      let(:options) { { :sidekiq_report_errors => "none" } }
+      before { call_handler }
 
       it "doesn't track the error on the transaction" do
         expect_no_error_on_transaction
@@ -155,10 +152,8 @@ describe Appsignal::Integrations::SidekiqErrorHandler do
     end
 
     context "when sidekiq_report_errors = all" do
-      before do
-        Appsignal.config[:sidekiq_report_errors] = "all"
-        call_handler
-      end
+      let(:options) { { :sidekiq_report_errors => "all" } }
+      before { call_handler }
 
       it "records each occurrence of the error on the transaction" do
         expect_error_on_transaction
@@ -167,10 +162,8 @@ describe Appsignal::Integrations::SidekiqErrorHandler do
     end
 
     context "when sidekiq_report_errors = discard" do
-      before do
-        Appsignal.config[:sidekiq_report_errors] = "discard"
-        call_handler
-      end
+      let(:options) { { :sidekiq_report_errors => "discard" } }
+      before { call_handler }
 
       it "doesn't track the error on the transaction" do
         expect_no_error_on_transaction
@@ -180,7 +173,7 @@ describe Appsignal::Integrations::SidekiqErrorHandler do
   end
 end
 
-describe Appsignal::Integrations::SidekiqMiddleware, :with_yaml_parse_error => false do
+describe Appsignal::Integrations::SidekiqMiddleware do
   class DelayedTestClass; end
 
   let(:namespace) { Appsignal::Transaction::BACKGROUND_JOB }
@@ -221,14 +214,14 @@ describe Appsignal::Integrations::SidekiqMiddleware, :with_yaml_parse_error => f
     }
   end
   let(:plugin) { Appsignal::Integrations::SidekiqMiddleware.new }
-  let(:log) { StringIO.new }
+  let(:options) { {} }
   before do
-    start_agent
-    Appsignal.internal_logger = test_logger(log)
+    start_agent(:options => options)
   end
   around { |example| keep_transactions { example.run } }
-  after :with_yaml_parse_error => false do
-    expect(log_contents(log)).to_not contains_log(:warn, "Unable to load YAML")
+
+  def expect_no_yaml_parse_error(logs)
+    expect(logs).to_not contains_log(:warn, "Unable to load YAML")
   end
 
   describe "internal Sidekiq job values" do
@@ -242,10 +235,7 @@ describe Appsignal::Integrations::SidekiqMiddleware, :with_yaml_parse_error => f
   end
 
   context "with parameter filtering" do
-    before do
-      start_agent("production")
-      Appsignal.config[:filter_parameters] = ["foo"]
-    end
+    let(:options) { { :filter_parameters => ["foo"] } }
 
     it "filters selected arguments" do
       perform_sidekiq_job
@@ -299,15 +289,15 @@ describe Appsignal::Integrations::SidekiqMiddleware, :with_yaml_parse_error => f
       expect(transaction).to include_params(["bar" => "baz"])
     end
 
-    context "when job arguments is a malformed YAML object", :with_yaml_parse_error => true do
+    context "when job arguments is a malformed YAML object" do
       before { item["args"] = [] }
 
       it "logs a warning and uses the default argument" do
-        perform_sidekiq_job
+        logs = capture_logs { perform_sidekiq_job }
 
         expect(transaction).to have_action("Sidekiq::Extensions::DelayedClass#perform")
         expect(transaction).to include_params([])
-        expect(log_contents(log)).to contains_log(:warn, "Unable to load YAML")
+        expect(logs).to contains_log(:warn, "Unable to load YAML")
       end
     end
   end
@@ -335,15 +325,15 @@ describe Appsignal::Integrations::SidekiqMiddleware, :with_yaml_parse_error => f
       expect(transaction).to include_params(["bar" => "baz"])
     end
 
-    context "when job arguments is a malformed YAML object", :with_yaml_parse_error => true do
+    context "when job arguments is a malformed YAML object" do
       before { item["args"] = [] }
 
       it "logs a warning and uses the default argument" do
-        perform_sidekiq_job
+        logs = capture_logs { perform_sidekiq_job }
 
         expect(transaction).to have_action("Sidekiq::Extensions::DelayedModel#perform")
         expect(transaction).to include_params([])
-        expect(log_contents(log)).to contains_log(:warn, "Unable to load YAML")
+        expect(logs).to contains_log(:warn, "Unable to load YAML")
       end
     end
   end
@@ -384,28 +374,24 @@ describe Appsignal::Integrations::SidekiqMiddleware, :with_yaml_parse_error => f
       include RailsHelper
 
       it "reports the worker name as the action, copies the namespace and tags" do
-        start_agent("production")
-        with_rails_error_reporter do
-          perform_sidekiq_job do
-            Appsignal.tag_job("test_tag" => "value")
-            Rails.error.handle do
-              raise ExampleStandardError, "uh oh"
+        expect do
+          with_rails_error_reporter do
+            perform_sidekiq_job do
+              Appsignal.tag_job("test_tag" => "value")
+              Rails.error.handle do
+                raise ExampleStandardError, "error message"
+              end
             end
           end
-        end
+        end.to change { created_transactions.count }.by(1)
 
-        expect(created_transactions.count).to eq(2)
         tags = { "test_tag" => "value" }
-        sidekiq_transaction = created_transactions.first
-        error_reporter_transaction = created_transactions.last
-
-        expect(sidekiq_transaction).to have_namespace("background_job")
-        expect(sidekiq_transaction).to have_action("TestClass#perform")
-        expect(sidekiq_transaction).to include_tags(tags)
+        transaction = last_transaction
 
-        expect(error_reporter_transaction).to have_namespace("background_job")
-        expect(error_reporter_transaction).to have_action("TestClass#perform")
-        expect(error_reporter_transaction).to include_tags(tags)
+        expect(transaction).to have_namespace("background_job")
+        expect(transaction).to have_action("TestClass#perform")
+        expect(transaction).to have_error("ExampleStandardError", "error message")
+        expect(transaction).to include_tags(tags)
       end
     end
   end

data/spec/lib/appsignal/loaders/hanami_spec.rb

@@ -1,18 +1,15 @@
 if DependencyHelper.hanami_present?
   describe "Appsignal::Loaders::HanamiLoader" do
-    before { Appsignal.config = nil }
-
     describe "#on_load" do
       it "registers Hanami default config" do
         load_loader(:hanami)
 
-        expect(Appsignal::Config.loader_defaults).to include([
-          :hanami,
-          {
-            :env => :test,
-            :root_path => Dir.pwd
-          }
-        ])
+        expect(Appsignal::Config.loader_defaults).to include(
+          :name => :hanami,
+          :root_path => Dir.pwd,
+          :env => :test,
+          :options => {}
+        )
       end
     end
 

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

@@ -1,18 +1,15 @@
 if DependencyHelper.padrino_present?
   describe "Appsignal::Loaders::PadrinoLoader" do
-    before { Appsignal.config = nil }
-
     describe "#on_load" do
       it "registers Padrino default config" do
         load_loader(:padrino)
 
-        expect(Appsignal::Config.loader_defaults).to include([
-          :padrino,
-          {
-            :env => :test,
-            :root_path => Padrino.mounted_root
-          }
-        ])
+        expect(Appsignal::Config.loader_defaults).to include(
+          :name => :padrino,
+          :root_path => Padrino.mounted_root,
+          :env => :test,
+          :options => {}
+        )
       end
     end
 
@@ -70,7 +67,6 @@ if DependencyHelper.padrino_present?
       # TODO: use an instance double
       let(:settings) { double(:name => "TestApp") }
       around { |example| keep_transactions { example.run } }
-      before { Appsignal.config = nil }
 
       describe "routes" do
         let(:env) do

data/spec/lib/appsignal/loaders/sinatra_spec.rb

@@ -1,19 +1,16 @@
 if DependencyHelper.sinatra_present?
   describe "Appsignal::Loaders::SinatraLoader" do
-    before { Appsignal.config = nil }
-
     describe "#on_load" do
       it "registers Sinatra default config" do
         ::Sinatra::Application.settings.root = "/some/path"
         load_loader(:sinatra)
 
-        expect(Appsignal::Config.loader_defaults).to include([
-          :sinatra,
-          {
-            :env => :test,
-            :root_path => "/some/path"
-          }
-        ])
+        expect(Appsignal::Config.loader_defaults).to include(
+          :name => :sinatra,
+          :root_path => "/some/path",
+          :env => :test,
+          :options => {}
+        )
       end
     end
 

data/spec/lib/appsignal/loaders_spec.rb

@@ -50,7 +50,14 @@ describe Appsignal::Loaders do
       end
       Appsignal::Loaders.load(:test_loader)
 
-      expect(Appsignal::Config.loader_defaults).to eq([[:test_loader, { :my_option => true }]])
+      expect(Appsignal::Config.loader_defaults).to eq([
+        {
+          :name => :test_loader,
+          :env => nil,
+          :root_path => nil,
+          :options => { :my_option => true }
+        }
+      ])
     end
 
     it "does not load errors that aren't registered" do

data/spec/lib/appsignal/marker_spec.rb

@@ -1,5 +1,5 @@
 describe Appsignal::Marker do
-  let(:config) { project_fixture_config }
+  let(:config) { build_config }
   let(:marker) do
     described_class.new(
       {

data/spec/lib/appsignal/probes_spec.rb

@@ -3,38 +3,6 @@ describe Appsignal::Probes do
 
   before { Appsignal::Probes.probes.clear }
 
-  context "Minutely constant" do
-    let(:err_stream) { std_stream }
-    let(:stderr) { err_stream.read }
-
-    it "returns the Probes constant calling the Minutely constant" do
-      silence { expect(Appsignal::Minutely).to be(Appsignal::Probes) }
-    end
-
-    it "prints a deprecation warning to STDERR" do
-      capture_std_streams(std_stream, err_stream) do
-        expect(Appsignal::Minutely).to be(Appsignal::Probes)
-      end
-
-      expect(stderr)
-        .to include("appsignal WARNING: The constant Appsignal::Minutely has been deprecated.")
-    end
-
-    it "logs a warning" do
-      logs =
-        capture_logs do
-          silence do
-            expect(Appsignal::Minutely).to be(Appsignal::Probes)
-          end
-        end
-
-      expect(logs).to contains_log(
-        :warn,
-        "The constant Appsignal::Minutely has been deprecated."
-      )
-    end
-  end
-
   it "returns a ProbeCollection" do
     expect(Appsignal::Probes.probes)
       .to be_instance_of(Appsignal::Probes::ProbeCollection)
@@ -128,12 +96,10 @@ describe Appsignal::Probes do
     context "with probe class" do
       it "creates an instance of the class and call that every <wait time>" do
         probe = MockProbe
-        probe_instance = MockProbe.new
-        expect(probe).to receive(:new).and_return(probe_instance)
         Appsignal::Probes.register :my_probe, probe
         Appsignal::Probes.start
 
-        wait_for("enough probe calls") { probe_instance.calls >= 2 }
+        wait_for("enough probe calls") { Appsignal::Testing.store[:mock_probe_call] >= 2 }
         expect(log).to contains_log(:debug, "Gathering minutely metrics with 1 probe")
         expect(log).to contains_log(:debug, "Gathering minutely metrics with 'my_probe' probe")
       end
@@ -142,15 +108,13 @@ describe Appsignal::Probes do
         it "does not initialize the probe" do
           # Working probe which we can use to wait for X ticks
           working_probe = ProbeWithoutDependency
-          working_probe_instance = working_probe.new
-          expect(working_probe).to receive(:new).and_return(working_probe_instance)
           Appsignal::Probes.register :probe_without_dep, working_probe
 
           probe = ProbeWithMissingDependency
           Appsignal::Probes.register :probe_with_missing_dep, probe
           Appsignal::Probes.start
 
-          wait_for("enough probe calls") { working_probe_instance.calls >= 2 }
+          wait_for("enough probe calls") { Appsignal::Testing.store[:mock_probe_call] >= 2 }
           # Only counts initialized probes
           expect(log).to contains_log(:debug, "Gathering minutely metrics with 1 probe")
           expect(log).to contains_log :debug, "Skipping 'probe_with_missing_dep' probe, " \
@@ -162,15 +126,13 @@ describe Appsignal::Probes do
         it "logs an error" do
           # Working probe which we can use to wait for X ticks
           working_probe = ProbeWithoutDependency
-          working_probe_instance = working_probe.new
-          expect(working_probe).to receive(:new).and_return(working_probe_instance)
           Appsignal::Probes.register :probe_without_dep, working_probe
 
           probe = BrokenProbeOnInitialize
           Appsignal::Probes.register :broken_probe_on_initialize, probe
           Appsignal::Probes.start
 
-          wait_for("enough probe calls") { working_probe_instance.calls >= 2 }
+          wait_for("enough probe calls") { Appsignal::Testing.store[:mock_probe_call] >= 2 }
           # Only counts initialized probes
           expect(log).to contains_log(:debug, "Gathering minutely metrics with 1 probe")
           # Logs error
@@ -398,45 +360,6 @@ describe Appsignal::Probes do
       end
     end
 
-    describe "#register" do
-      it "adds the probe by key" do
-        expect(Appsignal::Probes).to receive(:probes).and_return(collection)
-
-        probe = lambda {}
-        silence { collection.register :my_probe, probe }
-        expect(collection[:my_probe]).to eql(probe)
-      end
-
-      context "logger" do
-        before { start_agent }
-
-        it "logs a deprecation message" do
-          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
-      end
-
-      context "stderr" do
-        let(:err_stream) { std_stream }
-        let(:stderr) { err_stream.read }
-
-        it "prints a deprecation warning" do
-          capture_std_streams(std_stream, err_stream) do
-            collection.register :my_probe, lambda {}
-          end
-          deprecation_message =
-            "The method 'Appsignal::Probes.probes.register' is deprecated. " \
-              "Use 'Appsignal::Probes.register' instead."
-          expect(stderr).to include("appsignal WARNING: #{deprecation_message}")
-        end
-      end
-    end
-
     describe "#internal_register" do
       let(:log_stream) { std_stream }
       let(:log) { log_contents(log_stream) }
@@ -463,10 +386,8 @@ describe Appsignal::Probes do
 
     describe "#unregister" do
       it "removes the probe from the collection" do
-        expect(Appsignal::Probes).to receive(:probes).and_return(collection)
-
         probe = lambda {}
-        silence { collection.register :my_probe, probe }
+        silence { collection.internal_register :my_probe, probe }
         expect(collection[:my_probe]).to eql(probe)
 
         silence { collection.unregister :my_probe }

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

@@ -9,10 +9,11 @@ describe Appsignal::Rack::AbstractMiddleware do
       "rack.session" => { "session" => "data", "user_id" => 123 }
     )
   end
-  let(:options) { {} }
   let(:middleware) { described_class.new(app, options) }
 
-  before { start_agent }
+  let(:appsignal_env) { :default }
+  let(:options) { {} }
+  before { start_agent(:env => appsignal_env) }
   around { |example| keep_transactions { example.run } }
 
   def make_request
@@ -25,7 +26,7 @@ describe Appsignal::Rack::AbstractMiddleware do
 
   describe "#call" do
     context "when not active" do
-      before { allow(Appsignal).to receive(:active?).and_return(false) }
+      let(:appsignal_env) { :inactive_env }
 
       it "does not instrument the request" do
         expect { make_request }.to_not(change { created_transactions.count })
@@ -38,8 +39,6 @@ describe Appsignal::Rack::AbstractMiddleware do
     end
 
     context "when appsignal is active" do
-      before { allow(Appsignal).to receive(:active?).and_return(true) }
-
       it "creates a transaction for the request" do
         expect { make_request }.to(change { created_transactions.count }.by(1))
 
@@ -165,64 +164,6 @@ describe Appsignal::Rack::AbstractMiddleware do
         end
       end
 
-      context "with appsignal.route env" do
-        before { env["appsignal.route"] = "POST /my-route" }
-
-        it "reports the appsignal.route value as the action name" do
-          make_request
-
-          expect(last_transaction).to have_action("POST /my-route")
-        end
-
-        it "prints a deprecation warning" do
-          err_stream = std_stream
-          capture_std_streams(std_stream, err_stream) do
-            make_request
-          end
-
-          expect(err_stream.read).to include(
-            "Setting the action name with the request env 'appsignal.route' is deprecated."
-          )
-        end
-
-        it "logs a deprecation warning" do
-          logs = capture_logs { make_request }
-          expect(logs).to contains_log(
-            :warn,
-            "Setting the action name with the request env 'appsignal.route' is deprecated."
-          )
-        end
-      end
-
-      context "with appsignal.action env" do
-        before { env["appsignal.action"] = "POST /my-action" }
-
-        it "reports the appsignal.action value as the action name" do
-          make_request
-
-          expect(last_transaction).to have_action("POST /my-action")
-        end
-
-        it "prints a deprecation warning" do
-          err_stream = std_stream
-          capture_std_streams(std_stream, err_stream) do
-            make_request
-          end
-
-          expect(err_stream.read).to include(
-            "Setting the action name with the request env 'appsignal.action' is deprecated."
-          )
-        end
-
-        it "logs a deprecation warning" do
-          logs = capture_logs { make_request }
-          expect(logs).to contains_log(
-            :warn,
-            "Setting the action name with the request env 'appsignal.action' is deprecated."
-          )
-        end
-      end
-
       describe "request metadata" do
         it "sets request metadata" do
           env.merge!("PATH_INFO" => "/some/path", "REQUEST_METHOD" => "GET")

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

@@ -72,18 +72,6 @@ describe Appsignal::Rack::BodyWrapper do
       expect(transaction).to have_error("ExampleException", "error message")
     end
 
-    it "doesn't report EPIPE error" do
-      fake_body = double
-      expect(fake_body).to receive(:each).once.and_raise(Errno::EPIPE)
-
-      wrapped = described_class.wrap(fake_body, transaction)
-      expect do
-        expect { |b| wrapped.each(&b) }.to yield_control
-      end.to raise_error(Errno::EPIPE)
-
-      expect(transaction).to_not have_error
-    end
-
     it "closes the body and tracks an instrumentation event when it gets closed" do
       fake_body = double(:close => nil)
       expect(fake_body).to receive(:each).once.and_yield("a").and_yield("b").and_yield("c")
@@ -146,17 +134,6 @@ describe Appsignal::Rack::BodyWrapper do
       expect(transaction).to have_error("ExampleException", "error message")
     end
 
-    it "doesn't report EPIPE error" do
-      expect(fake_body).to receive(:each).once.and_raise(Errno::EPIPE)
-
-      wrapped = described_class.wrap(fake_body, transaction)
-      expect do
-        expect { |b| wrapped.each(&b) }.to yield_control
-      end.to raise_error(Errno::EPIPE)
-
-      expect(transaction).to_not have_error
-    end
-
     it "reads out the body in full using to_ary" do
       expect(fake_body).to receive(:to_ary).and_return(["one", "two", "three"])
 
@@ -230,17 +207,6 @@ describe Appsignal::Rack::BodyWrapper do
       expect(transaction).to have_error("ExampleException", "error message")
     end
 
-    it "doesn't report EPIPE error" do
-      expect(fake_body).to receive(:to_path).once.and_raise(Errno::EPIPE)
-
-      wrapped = described_class.wrap(fake_body, transaction)
-      expect do
-        wrapped.to_path
-      end.to raise_error(Errno::EPIPE)
-
-      expect(transaction).to_not have_error
-    end
-
     it "exposes to_path to the sender" do
       allow(fake_body).to receive(:to_path).and_return("/tmp/file.bin")
 
@@ -293,19 +259,5 @@ describe Appsignal::Rack::BodyWrapper do
 
       expect(transaction).to have_error("ExampleException", "error message")
     end
-
-    it "doesn't report EPIPE error" do
-      fake_rack_stream = double
-      expect(fake_body).to receive(:call)
-        .with(fake_rack_stream)
-        .and_raise(Errno::EPIPE)
-
-      wrapped = described_class.wrap(fake_body, transaction)
-      expect do
-        wrapped.call(fake_rack_stream)
-      end.to raise_error(Errno::EPIPE)
-
-      expect(transaction).to_not have_error
-    end
   end
 end