appsignal 2.1.0.beta.1 → 2.1.0

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

@@ -6,8 +6,8 @@ describe Appsignal::Rack::JSExceptionCatcher do
   let(:config)         { project_fixture_config("production", config_options) }
 
   before do
-    Appsignal.stub(:config => config)
-    config.stub(:active? => active)
+    allow(Appsignal).to receive(:config).and_return(config)
+    allow(config).to receive(:active?).and_return(active)
   end
 
   describe "#initialize" do

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

@@ -3,7 +3,7 @@ if DependencyHelper.rails_present?
   end
 
   describe Appsignal::Rack::RailsInstrumentation do
-    before :all do
+    before :context do
       start_agent
     end
 
@@ -20,11 +20,11 @@ if DependencyHelper.rails_present?
 
     describe "#call" do
       before do
-        middleware.stub(:raw_payload => {})
+        allow(middleware).to receive(:raw_payload).and_return({})
       end
 
       context "when appsignal is active" do
-        before { Appsignal.stub(:active? => true) }
+        before { allow(Appsignal).to receive(:active?).and_return(true) }
 
         it "should call with monitoring" do
           expect(middleware).to receive(:call_with_appsignal_monitoring).with(env)
@@ -32,7 +32,7 @@ if DependencyHelper.rails_present?
       end
 
       context "when appsignal is not active" do
-        before { Appsignal.stub(:active? => false) }
+        before { allow(Appsignal).to receive(:active?).and_return(false) }
 
         it "should not call with monitoring" do
           expect(middleware).to_not receive(:call_with_appsignal_monitoring)
@@ -48,7 +48,7 @@ if DependencyHelper.rails_present?
 
     describe "#call_with_appsignal_monitoring" do
       it "should create a transaction" do
-        Appsignal::Transaction.should_receive(:create).with(
+        expect(Appsignal::Transaction).to receive(:create).with(
           "1",
           Appsignal::Transaction::HTTP_REQUEST,
           kind_of(ActionDispatch::Request),
@@ -63,29 +63,29 @@ if DependencyHelper.rails_present?
       end
 
       it "should call the app" do
-        app.should_receive(:call).with(env)
+        expect(app).to receive(:call).with(env)
       end
 
       context "with an error" do
         let(:error) { VerySpecificError.new }
         let(:app) do
           double.tap do |d|
-            d.stub(:call).and_raise(error)
+            allow(d).to receive(:call).and_raise(error)
           end
         end
 
         it "should set the error" do
-          Appsignal::Transaction.any_instance.should_receive(:set_error).with(error)
+          expect_any_instance_of(Appsignal::Transaction).to receive(:set_error).with(error)
         end
       end
 
       it "should set metadata" do
-        Appsignal::Transaction.any_instance.should_receive(:set_metadata).twice
+        expect_any_instance_of(Appsignal::Transaction).to receive(:set_metadata).twice
       end
 
       it "should set the action and queue start" do
-        Appsignal::Transaction.any_instance.should_receive(:set_action).with("MockController#index")
-        Appsignal::Transaction.any_instance.should_receive(:set_http_or_background_queue_start)
+        expect_any_instance_of(Appsignal::Transaction).to receive(:set_action).with("MockController#index")
+        expect_any_instance_of(Appsignal::Transaction).to receive(:set_http_or_background_queue_start)
       end
 
       after { middleware.call(env) rescue VerySpecificError }
@@ -94,16 +94,20 @@ if DependencyHelper.rails_present?
     describe "#request_id" do
       subject { middleware.request_id(env) }
 
-      context "with request id set" do
+      context "with request id present" do
         let(:env) { { "action_dispatch.request_id" => "id" } }
 
-        it { should eq "id" }
+        it "returns the present id" do
+          is_expected.to eq "id"
+        end
       end
 
-      context "with request id not set" do
+      context "with request id not present" do
         let(:env) { {} }
 
-        its(:length) { should eq 36 }
+        it "sets a new id" do
+          expect(subject.length).to eq 36
+        end
       end
     end
   end

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

@@ -10,8 +10,8 @@ if DependencyHelper.sinatra_present?
     describe "#call" do
       before do
         start_agent
-        middleware.stub(:raw_payload => {})
-        Appsignal.stub(:active? => true)
+        allow(middleware).to receive(:raw_payload).and_return({})
+        allow(Appsignal).to receive(:active?).and_return(true)
       end
 
       it "should call without monitoring" do
@@ -31,7 +31,7 @@ if DependencyHelper.sinatra_present?
   end
 
   describe Appsignal::Rack::SinatraBaseInstrumentation do
-    before :all do
+    before :context do
       start_agent
     end
 
@@ -77,11 +77,11 @@ if DependencyHelper.sinatra_present?
 
     describe "#call" do
       before do
-        middleware.stub(:raw_payload => {})
+        allow(middleware).to receive(:raw_payload).and_return({})
       end
 
       context "when appsignal is active" do
-        before { Appsignal.stub(:active? => true) }
+        before { allow(Appsignal).to receive(:active?).and_return(true) }
 
         it "should call with monitoring" do
           expect(middleware).to receive(:call_with_appsignal_monitoring).with(env)
@@ -89,7 +89,7 @@ if DependencyHelper.sinatra_present?
       end
 
       context "when appsignal is not active" do
-        before { Appsignal.stub(:active? => false) }
+        before { allow(Appsignal).to receive(:active?).and_return(false) }
 
         it "should not call with monitoring" do
           expect(middleware).to_not receive(:call_with_appsignal_monitoring)
@@ -105,7 +105,7 @@ if DependencyHelper.sinatra_present?
 
     describe "#call_with_appsignal_monitoring" do
       it "should create a transaction" do
-        Appsignal::Transaction.should_receive(:create).with(
+        expect(Appsignal::Transaction).to receive(:create).with(
           kind_of(String),
           Appsignal::Transaction::HTTP_REQUEST,
           kind_of(Sinatra::Request),
@@ -114,20 +114,20 @@ if DependencyHelper.sinatra_present?
       end
 
       it "should call the app" do
-        app.should_receive(:call).with(env)
+        expect(app).to receive(:call).with(env)
       end
 
       context "with an error" do
         let(:error) { VerySpecificError.new }
         let(:app) do
           double.tap do |d|
-            d.stub(:call).and_raise(error)
-            d.stub(:settings => settings)
+            allow(d).to receive(:call).and_raise(error)
+            allow(d).to receive(:settings).and_return(settings)
           end
         end
 
         it "should set the error" do
-          Appsignal::Transaction.any_instance.should_receive(:set_error).with(error)
+          expect_any_instance_of(Appsignal::Transaction).to receive(:set_error).with(error)
         end
       end
 
@@ -136,14 +136,14 @@ if DependencyHelper.sinatra_present?
         let(:env) { { "sinatra.error" => error } }
 
         it "should set the error" do
-          Appsignal::Transaction.any_instance.should_receive(:set_error).with(error)
+          expect_any_instance_of(Appsignal::Transaction).to receive(:set_error).with(error)
         end
 
         context "if raise_errors is on" do
           let(:settings) { double(:raise_errors => true) }
 
           it "should not set the error" do
-            Appsignal::Transaction.any_instance.should_not_receive(:set_error)
+            expect_any_instance_of(Appsignal::Transaction).to_not receive(:set_error)
           end
         end
 
@@ -151,21 +151,21 @@ if DependencyHelper.sinatra_present?
           let(:env) { { "sinatra.error" => error, "sinatra.skip_appsignal_error" => true } }
 
           it "should not set the error" do
-            Appsignal::Transaction.any_instance.should_not_receive(:set_error)
+            expect_any_instance_of(Appsignal::Transaction).to_not receive(:set_error)
           end
         end
       end
 
       describe "action name" do
         it "should set the action" do
-          Appsignal::Transaction.any_instance.should_receive(:set_action).with("GET /")
+          expect_any_instance_of(Appsignal::Transaction).to receive(:set_action).with("GET /")
         end
 
         context "without 'sinatra.route' env" do
           let(:env) { { :path => "/", :method => "GET" } }
 
           it "returns nil" do
-            Appsignal::Transaction.any_instance.should_receive(:set_action).with(nil)
+            expect_any_instance_of(Appsignal::Transaction).to receive(:set_action).with(nil)
           end
         end
 
@@ -173,25 +173,25 @@ if DependencyHelper.sinatra_present?
           before { env["SCRIPT_NAME"] = "/api" }
 
           it "should call set_action with an application prefix path" do
-            Appsignal::Transaction.any_instance.should_receive(:set_action).with("GET /api/")
+            expect_any_instance_of(Appsignal::Transaction).to receive(:set_action).with("GET /api/")
           end
 
           context "without 'sinatra.route' env" do
             let(:env) { { :path => "/", :method => "GET" } }
 
             it "returns nil" do
-              Appsignal::Transaction.any_instance.should_receive(:set_action).with(nil)
+              expect_any_instance_of(Appsignal::Transaction).to receive(:set_action).with(nil)
             end
           end
         end
       end
 
       it "should set metadata" do
-        Appsignal::Transaction.any_instance.should_receive(:set_metadata).twice
+        expect_any_instance_of(Appsignal::Transaction).to receive(:set_metadata).twice
       end
 
       it "should set the queue start" do
-        Appsignal::Transaction.any_instance.should_receive(:set_http_or_background_queue_start)
+        expect_any_instance_of(Appsignal::Transaction).to receive(:set_http_or_background_queue_start)
       end
 
       context "with overridden request class and params method" do
@@ -199,7 +199,7 @@ if DependencyHelper.sinatra_present?
 
         it "should use the overridden request class and params method" do
           request = ::Rack::Request.new(env)
-          ::Rack::Request.should_receive(:new)
+          expect(::Rack::Request).to receive(:new)
             .with(env.merge(:params_method => :filtered_params))
             .at_least(:once)
             .and_return(request)

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

@@ -15,7 +15,7 @@ describe Appsignal::Rack::StreamingListener do
 
   describe "#call" do
     context "when Appsignal is active" do
-      before { Appsignal.stub(:active? => true) }
+      before { allow(Appsignal).to receive(:active?).and_return(true) }
 
       it "should call `call_with_appsignal_monitoring`" do
         expect(listener).to receive(:call_with_appsignal_monitoring)
@@ -23,7 +23,7 @@ describe Appsignal::Rack::StreamingListener do
     end
 
     context "when Appsignal is not active" do
-      before { Appsignal.stub(:active? => false) }
+      before { allow(Appsignal).to receive(:active?).and_return(false) }
 
       it "should not call `call_with_appsignal_monitoring`" do
         expect(listener).to_not receive(:call_with_appsignal_monitoring)
@@ -45,9 +45,9 @@ describe Appsignal::Rack::StreamingListener do
     let(:raw_payload) { { :foo => :bar } }
 
     before do
-      SecureRandom.stub(:uuid => "123")
-      listener.stub(:raw_payload => raw_payload)
-      Appsignal::Transaction.stub(:create => transaction)
+      allow(SecureRandom).to receive(:uuid).and_return("123")
+      allow(listener).to receive(:raw_payload).and_return(raw_payload)
+      allow(Appsignal::Transaction).to receive(:create).and_return(transaction)
     end
 
     it "should create a transaction" do

data/spec/lib/appsignal/system_spec.rb

@@ -6,7 +6,7 @@ describe Appsignal::System do
       around { |example| recognize_as_heroku { example.run } }
 
       it "returns true" do
-        expect(subject).to be_true
+        expect(subject).to be_truthy
       end
     end
 
@@ -14,7 +14,7 @@ describe Appsignal::System do
       around { |example| recognize_as_container(:docker) { example.run } }
 
       it "returns true" do
-        expect(subject).to be_true
+        expect(subject).to be_truthy
       end
     end
 
@@ -22,7 +22,7 @@ describe Appsignal::System do
       around { |example| recognize_as_container(:none) { example.run } }
 
       it "returns false" do
-        expect(subject).to be_false
+        expect(subject).to be_falsy
       end
     end
   end
@@ -34,7 +34,7 @@ describe Appsignal::System do
       around { |example| recognize_as_heroku { example.run } }
 
       it "returns true" do
-        expect(subject).to be_true
+        expect(subject).to be_truthy
       end
     end
 
@@ -42,7 +42,7 @@ describe Appsignal::System do
       around { |example| recognize_as_container(:none) { example.run } }
 
       it "returns false" do
-        expect(subject).to be_false
+        expect(subject).to be_falsy
       end
     end
   end

data/spec/lib/appsignal/transaction_spec.rb

@@ -1,13 +1,5 @@
-require_relative "../../support/mocks/fake_gc_profiler"
-
-class Smash < Hash
-  def []=(_key, _val)
-    raise "the roof"
-  end
-end
-
 describe Appsignal::Transaction do
-  before :all do
+  before :context do
     start_agent
   end
 
@@ -25,19 +17,19 @@ describe Appsignal::Transaction do
   describe "class methods" do
     describe ".create" do
       it "should add the transaction to thread local" do
-        Appsignal::Extension.should_receive(:start_transaction).with("1", "http_request", 0)
+        expect(Appsignal::Extension).to receive(:start_transaction).with("1", "http_request", 0)
 
         created_transaction = Appsignal::Transaction.create("1", namespace, request, options)
 
-        Thread.current[:appsignal_transaction].should eq created_transaction
+        expect(Thread.current[:appsignal_transaction]).to eq created_transaction
       end
 
       it "should create a transaction" do
         created_transaction = Appsignal::Transaction.create("1", namespace, request, options)
 
-        created_transaction.should be_a Appsignal::Transaction
-        created_transaction.transaction_id.should eq "1"
-        created_transaction.namespace.should eq "http_request"
+        expect(created_transaction).to be_a Appsignal::Transaction
+        expect(created_transaction.transaction_id).to eq "1"
+        expect(created_transaction.namespace).to eq "http_request"
       end
 
       context "when a transaction is already running" do
@@ -77,11 +69,11 @@ describe Appsignal::Transaction do
         before { Appsignal::Transaction.create("1", namespace, request, options) }
 
         it "should return the correct transaction" do
-          should eq transaction
+          is_expected.to eq transaction
         end
 
         it "should indicate it's not a nil transaction" do
-          subject.nil_transaction?.should be_false
+          expect(subject.nil_transaction?).to be_falsy
         end
       end
 
@@ -91,11 +83,11 @@ describe Appsignal::Transaction do
         end
 
         it "should return a nil transaction stub" do
-          should be_a Appsignal::Transaction::NilTransaction
+          is_expected.to be_a Appsignal::Transaction::NilTransaction
         end
 
         it "should indicate it's a nil transaction" do
-          subject.nil_transaction?.should be_true
+          expect(subject.nil_transaction?).to be_truthy
         end
       end
     end
@@ -104,19 +96,19 @@ describe Appsignal::Transaction do
       before { Appsignal::Transaction.create("2", Appsignal::Transaction::HTTP_REQUEST, {}) }
 
       it "should complete the current transaction and set the thread appsignal_transaction to nil" do
-        Appsignal::Transaction.current.should_receive(:complete)
+        expect(Appsignal::Transaction.current).to receive(:complete)
 
         Appsignal::Transaction.complete_current!
 
-        Thread.current[:appsignal_transaction].should be_nil
+        expect(Thread.current[:appsignal_transaction]).to be_nil
       end
 
       it "should still clear the transaction if there is an error" do
-        Appsignal::Transaction.current.should_receive(:complete).and_raise "Error"
+        expect(Appsignal::Transaction.current).to receive(:complete).and_raise "Error"
 
         Appsignal::Transaction.complete_current!
 
-        Thread.current[:appsignal_transaction].should be_nil
+        expect(Thread.current[:appsignal_transaction]).to be_nil
       end
 
       context "if a transaction is discarded" do
@@ -124,18 +116,18 @@ describe Appsignal::Transaction do
           expect(Appsignal::Transaction.current.ext).to_not receive(:complete)
 
           Appsignal::Transaction.current.discard!
-          expect(Appsignal::Transaction.current.discarded?).to be_true
+          expect(Appsignal::Transaction.current.discarded?).to be_truthy
 
           Appsignal::Transaction.complete_current!
 
-          Thread.current[:appsignal_transaction].should be_nil
+          expect(Thread.current[:appsignal_transaction]).to be_nil
         end
 
         it "should not be discarded when restore! is called" do
           Appsignal::Transaction.current.discard!
-          expect(Appsignal::Transaction.current.discarded?).to be_true
+          expect(Appsignal::Transaction.current.discarded?).to be_truthy
           Appsignal::Transaction.current.restore!
-          expect(Appsignal::Transaction.current.discarded?).to be_false
+          expect(Appsignal::Transaction.current.discarded?).to be_falsy
         end
       end
     end
@@ -143,17 +135,17 @@ describe Appsignal::Transaction do
 
   describe "#complete" do
     it "should sample data if it needs to be sampled" do
-      transaction.ext.should_receive(:finish).and_return(true)
-      transaction.should_receive(:sample_data)
-      transaction.ext.should_receive(:complete)
+      expect(transaction.ext).to receive(:finish).and_return(true)
+      expect(transaction).to receive(:sample_data)
+      expect(transaction.ext).to receive(:complete)
 
       transaction.complete
     end
 
     it "should not sample data if it does not need to be sampled" do
-      transaction.ext.should_receive(:finish).and_return(false)
-      transaction.should_not_receive(:sample_data)
-      transaction.ext.should_receive(:complete)
+      expect(transaction.ext).to receive(:finish).and_return(false)
+      expect(transaction).to_not receive(:sample_data)
+      expect(transaction.ext).to receive(:complete)
 
       transaction.complete
     end
@@ -180,14 +172,14 @@ describe Appsignal::Transaction do
 
     describe "#paused?" do
       it "should return the pause state" do
-        expect(transaction.paused?).to be_false
+        expect(transaction.paused?).to be_falsy
       end
 
       context "when paused" do
         before { transaction.pause! }
 
         it "should return the pause state" do
-          expect(transaction.paused?).to be_true
+          expect(transaction.paused?).to be_truthy
         end
       end
     end
@@ -195,24 +187,43 @@ describe Appsignal::Transaction do
 
   context "with transaction instance" do
     context "initialization" do
-      subject { transaction }
+      it "loads the AppSignal extension" do
+        expect(transaction.ext).to_not be_nil
+      end
+
+      it "sets the transaction id" do
+        expect(transaction.transaction_id).to eq "1"
+      end
+
+      it "sets the namespace to http_request" do
+        expect(transaction.namespace).to eq "http_request"
+      end
+
+      it "sets the request" do
+        expect(transaction.request).to_not be_nil
+      end
 
-      its(:ext)                { should_not be_nil }
-      its(:transaction_id)     { should eq "1" }
-      its(:namespace)          { should eq "http_request" }
-      its(:request)            { should_not be_nil }
-      its(:paused)             { should be_false }
-      its(:tags)               { should eq({}) }
+      it "sets the request not to paused" do
+        expect(transaction.paused).to be_falsy
+      end
+
+      it "sets no tags by default" do
+        expect(transaction.tags).to eq({})
+      end
 
-      context "options" do
+      describe "#options" do
         subject { transaction.options }
 
-        its([:params_method]) { should eq :params }
+        it "sets the default :params_method" do
+          expect(subject[:params_method]).to eq :params
+        end
 
         context "with overridden options" do
           let(:options) { { :params_method => :filtered_params } }
 
-          its([:params_method]) { should eq :filtered_params }
+          it "sets the overriden :params_method" do
+            expect(subject[:params_method]).to eq :filtered_params
+          end
         end
       end
     end
@@ -240,7 +251,7 @@ describe Appsignal::Transaction do
 
     describe "set_action" do
       it "should set the action in extension" do
-        transaction.ext.should_receive(:set_action).with(
+        expect(transaction.ext).to receive(:set_action).with(
           "PagesController#show"
         ).once
 
@@ -248,7 +259,7 @@ describe Appsignal::Transaction do
       end
 
       it "should not set the action in extension when value is nil" do
-        Appsignal::Extension.should_not_receive(:set_transaction_action)
+        expect(Appsignal::Extension).to_not receive(:set_transaction_action)
 
         transaction.set_action(nil)
       end
@@ -259,7 +270,7 @@ describe Appsignal::Transaction do
         let(:from) { { :controller => "HomeController", :action => "show" } }
 
         it "should set the action" do
-          transaction.should_receive(:set_action).with("HomeController#show")
+          expect(transaction).to receive(:set_action).with("HomeController#show")
         end
       end
 
@@ -267,7 +278,7 @@ describe Appsignal::Transaction do
         let(:from) { { :action => "show" } }
 
         it "should set the action" do
-          transaction.should_receive(:set_action).with("show")
+          expect(transaction).to receive(:set_action).with("show")
         end
       end
 
@@ -275,7 +286,7 @@ describe Appsignal::Transaction do
         let(:from) { { :class => "Worker", :method => "perform" } }
 
         it "should set the action" do
-          transaction.should_receive(:set_action).with("Worker#perform")
+          expect(transaction).to receive(:set_action).with("Worker#perform")
         end
       end
 
@@ -284,7 +295,7 @@ describe Appsignal::Transaction do
 
     describe "set_queue_start" do
       it "should set the queue start in extension" do
-        transaction.ext.should_receive(:set_queue_start).with(
+        expect(transaction.ext).to receive(:set_queue_start).with(
           10.0
         ).once
 
@@ -292,19 +303,19 @@ describe Appsignal::Transaction do
       end
 
       it "should not set the queue start in extension when value is nil" do
-        transaction.ext.should_not_receive(:set_queue_start)
+        expect(transaction.ext).to_not receive(:set_queue_start)
 
         transaction.set_queue_start(nil)
       end
 
       it "should not raise an error when the queue start is too big" do
-        transaction.ext.should_receive(:set_queue_start).and_raise(RangeError)
+        expect(transaction.ext).to receive(:set_queue_start).and_raise(RangeError)
 
-        Appsignal.logger.should_receive(:warn).with("Queue start value 10 is too big")
+        expect(Appsignal.logger).to receive(:warn).with("Queue start value 10 is too big")
 
-        lambda do
+        expect do
           transaction.set_queue_start(10)
-        end.should_not raise_error
+        end.to_not raise_error
       end
     end
 
@@ -314,7 +325,7 @@ describe Appsignal::Transaction do
         let(:env) { { "HTTP_X_REQUEST_START" => (fixed_time * 1000).to_s } }
 
         it "should set the queue start on the transaction" do
-          transaction.should_receive(:set_queue_start).with(13_897_836_000)
+          expect(transaction).to receive(:set_queue_start).with(13_897_836_000)
 
           transaction.set_http_or_background_queue_start
         end
@@ -325,7 +336,7 @@ describe Appsignal::Transaction do
         let(:env) { { :queue_start => fixed_time } }
 
         it "should set the queue start on the transaction" do
-          transaction.should_receive(:set_queue_start).with(1_389_783_600_000)
+          expect(transaction).to receive(:set_queue_start).with(1_389_783_600_000)
 
           transaction.set_http_or_background_queue_start
         end
@@ -334,7 +345,7 @@ describe Appsignal::Transaction do
 
     describe "#set_metadata" do
       it "should set the metdata in extension" do
-        transaction.ext.should_receive(:set_metadata).with(
+        expect(transaction.ext).to receive(:set_metadata).with(
           "request_method",
           "GET"
         ).once
@@ -343,7 +354,7 @@ describe Appsignal::Transaction do
       end
 
       it "should not set the metdata in extension when value is nil" do
-        transaction.ext.should_not_receive(:set_metadata)
+        expect(transaction.ext).to_not receive(:set_metadata)
 
         transaction.set_metadata("request_method", nil)
       end
@@ -351,7 +362,7 @@ describe Appsignal::Transaction do
 
     describe "set_sample_data" do
       it "should set the data" do
-        transaction.ext.should_receive(:set_sample_data).with(
+        expect(transaction.ext).to receive(:set_sample_data).with(
           "params",
           Appsignal::Utils.data_generate("controller" => "blog_posts", "action" => "show", "id" => "1")
         ).once
@@ -365,7 +376,7 @@ describe Appsignal::Transaction do
       end
 
       it "should do nothing if the data cannot be converted to json" do
-        transaction.ext.should_not_receive(:set_sample_data).with(
+        expect(transaction.ext).to_not receive(:set_sample_data).with(
           "params",
           kind_of(String)
         )
@@ -376,7 +387,7 @@ describe Appsignal::Transaction do
 
     describe "#sample_data" do
       it "should sample data" do
-        transaction.ext.should_receive(:set_sample_data).with(
+        expect(transaction.ext).to receive(:set_sample_data).with(
           "environment",
           Appsignal::Utils.data_generate(
             "CONTENT_LENGTH" => "0",
@@ -386,19 +397,19 @@ describe Appsignal::Transaction do
             "PATH_INFO" => "/blog"
           )
         ).once
-        transaction.ext.should_receive(:set_sample_data).with(
+        expect(transaction.ext).to receive(:set_sample_data).with(
           "session_data",
           Appsignal::Utils.data_generate({})
         ).once
-        transaction.ext.should_receive(:set_sample_data).with(
+        expect(transaction.ext).to receive(:set_sample_data).with(
           "params",
           Appsignal::Utils.data_generate("controller" => "blog_posts", "action" => "show", "id" => "1")
         ).once
-        transaction.ext.should_receive(:set_sample_data).with(
+        expect(transaction.ext).to receive(:set_sample_data).with(
           "metadata",
           Appsignal::Utils.data_generate("key" => "value")
         ).once
-        transaction.ext.should_receive(:set_sample_data).with(
+        expect(transaction.ext).to receive(:set_sample_data).with(
           "tags",
           Appsignal::Utils.data_generate({})
         ).once
@@ -412,20 +423,20 @@ describe Appsignal::Transaction do
       let(:error) { double(:error, :message => "test message", :backtrace => ["line 1"]) }
 
       it "should also respond to add_exception for backwords compatibility" do
-        transaction.should respond_to(:add_exception)
+        expect(transaction).to respond_to(:add_exception)
       end
 
       it "should not add the error if appsignal is not active" do
-        Appsignal.stub(:active? => false)
-        transaction.ext.should_not_receive(:set_error)
+        allow(Appsignal).to receive(:active?).and_return(false)
+        expect(transaction.ext).to_not receive(:set_error)
 
         transaction.set_error(error)
       end
 
       context "for a http request" do
         it "should set an error in the extension" do
-          transaction.ext.should_receive(:set_error).with(
-            "RSpec::Mocks::Mock",
+          expect(transaction.ext).to receive(:set_error).with(
+            "RSpec::Mocks::Double",
             "test message",
             Appsignal::Utils.data_generate(["line 1"])
           )
@@ -442,8 +453,8 @@ describe Appsignal::Transaction do
         end
 
         it "should set an error in the extension" do
-          transaction.ext.should_receive(:set_error).with(
-            "RSpec::Mocks::Mock",
+          expect(transaction.ext).to receive(:set_error).with(
+            "RSpec::Mocks::Double",
             "",
             Appsignal::Utils.data_generate(["line 1"])
           )
@@ -455,21 +466,27 @@ describe Appsignal::Transaction do
 
     describe "#start_event" do
       it "should start the event in the extension" do
-        transaction.ext.should_receive(:start_event)
+        expect(transaction.ext).to receive(:start_event).with(0).and_call_original
 
         transaction.start_event
       end
     end
 
     describe "#finish_event" do
+      let(:fake_gc_time) { 123 }
+      before do
+        expect(described_class.garbage_collection_profiler)
+          .to receive(:total_time).at_least(:once).and_return(fake_gc_time)
+      end
+
       it "should finish the event in the extension" do
-        transaction.ext.should_receive(:finish_event).with(
+        expect(transaction.ext).to receive(:finish_event).with(
           "name",
           "title",
           "body",
           1,
-          0
-        )
+          fake_gc_time
+        ).and_call_original
 
         transaction.finish_event(
           "name",
@@ -480,13 +497,13 @@ describe Appsignal::Transaction do
       end
 
       it "should finish the event in the extension with nil arguments" do
-        transaction.ext.should_receive(:finish_event).with(
+        expect(transaction.ext).to receive(:finish_event).with(
           "name",
           "",
           "",
           0,
-          0
-        )
+          fake_gc_time
+        ).and_call_original
 
         transaction.finish_event(
           "name",
@@ -495,25 +512,24 @@ describe Appsignal::Transaction do
           nil
         )
       end
-
-      it "should add garbage collection time" do
-        allow_any_instance_of(Appsignal::GarbageCollectionProfiler)
-          .to receive(:internal_profiler)
-          .and_return(FakeGCProfiler.new(0.12345))
-
-        transaction.finish_event("name", nil, nil, nil)
-      end
     end
 
     describe "#record_event" do
+      let(:fake_gc_time) { 123 }
+      before do
+        expect(described_class.garbage_collection_profiler)
+          .to receive(:total_time).at_least(:once).and_return(fake_gc_time)
+      end
+
       it "should record the event in the extension" do
-        transaction.ext.should_receive(:record_event).with(
+        expect(transaction.ext).to receive(:record_event).with(
           "name",
           "title",
           "body",
           1000,
-          1
-        )
+          1,
+          fake_gc_time
+        ).and_call_original
 
         transaction.record_event(
           "name",
@@ -525,13 +541,14 @@ describe Appsignal::Transaction do
       end
 
       it "should finish the event in the extension with nil arguments" do
-        transaction.ext.should_receive(:record_event).with(
+        expect(transaction.ext).to receive(:record_event).with(
           "name",
           "",
           "",
           1000,
-          0
-        )
+          0,
+          fake_gc_time
+        ).and_call_original
 
         transaction.record_event(
           "name",
@@ -546,19 +563,20 @@ describe Appsignal::Transaction do
     describe "#instrument" do
       it "should start and finish an event around the given block" do
         stub = double
-        stub.should_receive(:method_call).and_return("return value")
+        expect(stub).to receive(:method_call).and_return("return value")
 
-        transaction.should_receive(:start_event)
-        transaction.should_receive(:finish_event).with(
+        expect(transaction).to receive(:start_event)
+        expect(transaction).to receive(:finish_event).with(
           "name",
           "title",
           "body",
           0
         )
 
-        transaction.instrument "name", "title", "body" do
+        return_value = transaction.instrument "name", "title", "body" do
           stub.method_call
-        end.should eq "return value"
+        end
+        expect(return_value).to eq "return value"
       end
     end
 
@@ -566,11 +584,11 @@ describe Appsignal::Transaction do
       let(:env) { {} }
       subject { Appsignal::Transaction::GenericRequest.new(env) }
 
-      it "should initialize with an empty env" do
-        subject.env.should be_empty
+      it "initializes with an empty env" do
+        expect(subject.env).to be_empty
       end
 
-      context "with a filled env" do
+      context "when given an env" do
         let(:env) do
           {
             :params => { :id => 1 },
@@ -578,8 +596,13 @@ describe Appsignal::Transaction do
           }
         end
 
-        its(:env) { should eq env }
-        its(:params) { should eq(:id => 1) }
+        it "sets the given env" do
+          expect(subject.env).to eq env
+        end
+
+        it "sets the params present in the env" do
+          expect(subject.params).to eq(:id => 1)
+        end
       end
     end
 
@@ -591,23 +614,23 @@ describe Appsignal::Transaction do
       context "when request is nil" do
         let(:request) { nil }
 
-        it { should eq nil }
+        it { is_expected.to eq nil }
       end
 
       context "when env is nil" do
         before { expect(transaction.request).to receive(:env).and_return(nil) }
 
-        it { should eq nil }
+        it { is_expected.to eq nil }
       end
 
       context "when queue start is nil" do
-        it { should eq nil }
+        it { is_expected.to eq nil }
       end
 
       context "when queue start is set" do
         let(:env) { background_env_with_data }
 
-        it { should eq 1_389_783_590_000 }
+        it { is_expected.to eq 1_389_783_590_000 }
       end
     end
 
@@ -620,48 +643,48 @@ describe Appsignal::Transaction do
         context "when request is nil" do
           let(:request) { nil }
 
-          it { should be_nil }
+          it { is_expected.to be_nil }
         end
 
         context "when env is nil" do
           before { expect(transaction.request).to receive(:env).and_return(nil) }
 
-          it { should be_nil }
+          it { is_expected.to be_nil }
         end
 
         context "with no relevant header set" do
           let(:env) { {} }
 
-          it { should be_nil }
+          it { is_expected.to be_nil }
         end
 
         context "with the HTTP_X_REQUEST_START header set" do
           let(:env) { { "HTTP_X_REQUEST_START" => "t=#{slightly_earlier_time_value}" } }
 
-          it { should eq 1_389_783_599_600 }
+          it { is_expected.to eq 1_389_783_599_600 }
 
           context "with unparsable content" do
             let(:env) { { "HTTP_X_REQUEST_START" => "something" } }
 
-            it { should be_nil }
+            it { is_expected.to be_nil }
           end
 
           context "with some cruft" do
             let(:env) { { "HTTP_X_REQUEST_START" => "t=#{slightly_earlier_time_value}aaaa" } }
 
-            it { should eq 1_389_783_599_600 }
+            it { is_expected.to eq 1_389_783_599_600 }
           end
 
           context "with a really low number" do
             let(:env) { { "HTTP_X_REQUEST_START" => "t=100" } }
 
-            it { should be_nil }
+            it { is_expected.to be_nil }
           end
 
           context "with the alternate HTTP_X_QUEUE_START header set" do
             let(:env) { { "HTTP_X_QUEUE_START" => "t=#{slightly_earlier_time_value}" } }
 
-            it { should eq 1_389_783_599_600 }
+            it { is_expected.to eq 1_389_783_599_600 }
           end
         end
       end
@@ -683,28 +706,28 @@ describe Appsignal::Transaction do
       subject { transaction.send(:sanitized_params) }
 
       context "without params" do
-        before { transaction.request.stub(:params => nil) }
+        before { allow(transaction.request).to receive(:params).and_return(nil) }
 
-        it { should be_nil }
+        it { is_expected.to be_nil }
       end
 
       context "when params crashes" do
-        before { transaction.request.stub(:params).and_raise(NoMethodError) }
+        before { allow(transaction.request).to receive(:params).and_raise(NoMethodError) }
 
-        it { should be_nil }
+        it { is_expected.to be_nil }
       end
 
       context "when params method does not exist" do
         let(:options) { { :params_method => :nonsense } }
 
-        it { should be_nil }
+        it { is_expected.to be_nil }
       end
 
       context "when not sending params" do
         before { Appsignal.config.config_hash[:send_params] = false }
         after { Appsignal.config.config_hash[:send_params] = true }
 
-        it { should be_nil }
+        it { is_expected.to be_nil }
       end
 
       context "with an array" do
@@ -712,13 +735,13 @@ describe Appsignal::Transaction do
           Appsignal::Transaction::GenericRequest.new(background_env_with_data(:params => ["arg1", "arg2"]))
         end
 
-        it { should eq ["arg1", "arg2"] }
+        it { is_expected.to eq ["arg1", "arg2"] }
 
         context "with AppSignal filtering" do
           before { Appsignal.config.config_hash[:filter_parameters] = %w(foo) }
           after { Appsignal.config.config_hash[:filter_parameters] = [] }
 
-          it { should eq ["arg1", "arg2"] }
+          it { is_expected.to eq ["arg1", "arg2"] }
         end
       end
 
@@ -731,7 +754,7 @@ describe Appsignal::Transaction do
 
           it "should call the params sanitizer" do
             puts Appsignal.config.config_hash[:filter_parameters].inspect
-            subject.should eq(:foo => :bar)
+            expect(subject).to eq(:foo => :bar)
           end
         end
 
@@ -744,7 +767,7 @@ describe Appsignal::Transaction do
           after { Appsignal.config.config_hash[:filter_parameters] = [] }
 
           it "should call the params sanitizer with filtering" do
-            subject.should eq(:foo => "[FILTERED]", :baz => :bat)
+            expect(subject).to eq(:foo => "[FILTERED]", :baz => :bat)
           end
         end
       end
@@ -758,15 +781,13 @@ describe Appsignal::Transaction do
       context "when request is nil" do
         let(:request) { nil }
 
-        it "returns nil" do
-          expect(subject).to be_nil
-        end
+        it { is_expected.to be_nil }
       end
 
       context "when env is nil" do
         before { expect(transaction.request).to receive(:env).and_return(nil) }
 
-        it { should be_nil }
+        it { is_expected.to be_nil }
       end
 
       context "when env is present" do
@@ -778,7 +799,9 @@ describe Appsignal::Transaction do
           end
         end
 
-        its(:keys) { should =~ whitelisted_keys[0, whitelisted_keys.length] }
+        it "only sets whitelisted keys" do
+          expect(subject.keys).to match_array(whitelisted_keys)
+        end
       end
     end
 
@@ -788,52 +811,50 @@ describe Appsignal::Transaction do
       context "when request is nil" do
         let(:request) { nil }
 
-        it "returns nil" do
-          expect(subject).to be_nil
-        end
+        it { is_expected.to be_nil }
       end
 
       context "when session is nil" do
         before { expect(transaction.request).to receive(:session).and_return(nil) }
 
-        it { should be_nil }
+        it { is_expected.to be_nil }
       end
 
       context "when session is empty" do
         before { expect(transaction.request).to receive(:session).and_return({}) }
 
-        it { should eq({}) }
+        it { is_expected.to eq({}) }
       end
 
       context "when request class does not have a session method" do
         let(:request) { Appsignal::Transaction::GenericRequest.new({}) }
 
-        it { should be_nil }
+        it { is_expected.to be_nil }
       end
 
       context "when there is a session" do
         before do
-          transaction.should respond_to(:request)
-          transaction.stub_chain(:request, :session => { :foo => :bar })
-          transaction.stub_chain(:request, :fullpath => :bar)
+          expect(transaction).to respond_to(:request)
+          allow(transaction).to receive_message_chain(:request, :session => { :foo => :bar })
+          allow(transaction).to receive_message_chain(:request, :fullpath => :bar)
         end
 
         it "passes the session data into the params sanitizer" do
-          Appsignal::Utils::ParamsSanitizer.should_receive(:sanitize).with(:foo => :bar)
+          expect(Appsignal::Utils::ParamsSanitizer).to receive(:sanitize).with(:foo => :bar)
             .and_return(:sanitized_foo)
-          subject.should eq :sanitized_foo
+          expect(subject).to eq :sanitized_foo
         end
 
         if defined? ActionDispatch::Request::Session
           context "with ActionDispatch::Request::Session" do
             before do
-              transaction.should respond_to(:request)
-              transaction.stub_chain(:request, :session => action_dispatch_session)
-              transaction.stub_chain(:request, :fullpath => :bar)
+              expect(transaction).to respond_to(:request)
+              allow(transaction).to receive_message_chain(:request, :session => action_dispatch_session)
+              allow(transaction).to receive_message_chain(:request, :fullpath => :bar)
             end
 
             it "should return an session hash" do
-              Appsignal::Utils::ParamsSanitizer.should_receive(:sanitize).with("foo" => :bar)
+              expect(Appsignal::Utils::ParamsSanitizer).to receive(:sanitize).with("foo" => :bar)
                 .and_return(:sanitized_foo)
               subject
             end
@@ -859,8 +880,8 @@ describe Appsignal::Transaction do
           end
 
           it "does not pass the session data into the params sanitizer" do
-            Appsignal::Utils::ParamsSanitizer.should_not_receive(:sanitize)
-            subject.should be_nil
+            expect(Appsignal::Utils::ParamsSanitizer).to_not receive(:sanitize)
+            expect(subject).to be_nil
           end
         end
       end
@@ -872,19 +893,19 @@ describe Appsignal::Transaction do
       context "when request is nil" do
         let(:request) { nil }
 
-        it { should be_nil }
+        it { is_expected.to be_nil }
       end
 
       context "when env is nil" do
         before { expect(transaction.request).to receive(:env).and_return(nil) }
 
-        it { should be_nil }
+        it { is_expected.to be_nil }
       end
 
       context "when env is present" do
         let(:env) { { :metadata => { :key => "value" } } }
 
-        it { should eq env[:metadata] }
+        it { is_expected.to eq env[:metadata] }
       end
     end
 
@@ -905,12 +926,12 @@ describe Appsignal::Transaction do
       subject { transaction.send(:sanitized_tags).keys }
 
       it "should only return whitelisted data" do
-        should =~ [
+        is_expected.to match_array([
           :valid_key,
           "valid_string_key",
           :both_symbols,
           :integer_value
-        ]
+        ])
       end
     end
 
@@ -938,7 +959,7 @@ describe Appsignal::Transaction do
     subject { Appsignal::Transaction::NilTransaction.new }
 
     it "should have method stubs" do
-      lambda do
+      expect do
         subject.complete
         subject.pause!
         subject.resume!
@@ -953,7 +974,7 @@ describe Appsignal::Transaction do
         subject.set_sample_data("key", "data")
         subject.sample_data
         subject.set_error("a")
-      end.should_not raise_error
+      end.to_not raise_error
     end
   end
 end