appsignal 2.1.0.alpha.3 → 2.1.0.beta.1

data/spec/lib/appsignal/system/container_spec.rb

@@ -43,7 +43,7 @@ describe Appsignal::System::Container do
     context "when no permission to read cgroup file" do
       let(:out_stream) { StringIO.new }
       let(:no_permission_file) do
-        File.join(fixtures_dir, 'containers', 'cgroups', 'no_permission')
+        File.join(fixtures_dir, "containers", "cgroups", "no_permission")
       end
       before do
         File.chmod 0333, no_permission_file

data/spec/lib/appsignal/transaction_spec.rb

@@ -1,8 +1,8 @@
-require_relative '../../support/mocks/fake_gc_profiler'
+require_relative "../../support/mocks/fake_gc_profiler"
 
 class Smash < Hash
-  def []=(key, val)
-    raise 'the roof'
+  def []=(_key, _val)
+    raise "the roof"
   end
 end
 
@@ -17,27 +17,27 @@ describe Appsignal::Transaction do
   let(:merged_env)  { http_request_env_with_data(env) }
   let(:options)     { {} }
   let(:request)     { Rack::Request.new(merged_env) }
-  let(:transaction) { Appsignal::Transaction.new('1', namespace, request, options) }
+  let(:transaction) { Appsignal::Transaction.new("1", namespace, request, options) }
 
   before { Timecop.freeze(time) }
   after  { Timecop.return }
 
-  context "class methods" 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)
+        Appsignal::Extension.should_receive(:start_transaction).with("1", "http_request", 0)
 
-        created_transaction = Appsignal::Transaction.create('1', namespace, request, options)
+        created_transaction = Appsignal::Transaction.create("1", namespace, request, options)
 
         Thread.current[:appsignal_transaction].should eq created_transaction
       end
 
       it "should create a transaction" do
-        created_transaction = Appsignal::Transaction.create('1', namespace, request, options)
+        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'
+        created_transaction.transaction_id.should eq "1"
+        created_transaction.namespace.should eq "http_request"
       end
 
       context "when a transaction is already running" do
@@ -46,36 +46,35 @@ describe Appsignal::Transaction do
 
         it "should not create a new transaction" do
           expect(
-            Appsignal::Transaction.create('1', namespace, request, options)
+            Appsignal::Transaction.create("1", namespace, request, options)
           ).to eq(running_transaction)
         end
 
         it "should output a debug message" do
-          expect( Appsignal.logger ).to receive(:debug)
+          expect(Appsignal.logger).to receive(:debug)
             .with("Trying to start new transaction 1 but 2 is already running. Using 2")
 
-          Appsignal::Transaction.create('1', namespace, request, options)
+          Appsignal::Transaction.create("1", namespace, request, options)
         end
 
         context "with option to force a new transaction" do
-          let(:options) { {:force => true} }
+          let(:options) { { :force => true } }
           it "should not create a new transaction" do
             expect(
-              Appsignal::Transaction.create('1', namespace, request, options)
+              Appsignal::Transaction.create("1", namespace, request, options)
             ).to_not eq(running_transaction)
           end
         end
-
       end
     end
 
-    describe '.current' do
+    describe ".current" do
       before { Thread.current[:appsignal_transaction] = transaction }
 
       subject { Appsignal::Transaction.current }
 
       context "if there is a transaction" do
-        before { Appsignal::Transaction.create('1', namespace, request, options) }
+        before { Appsignal::Transaction.create("1", namespace, request, options) }
 
         it "should return the correct transaction" do
           should eq transaction
@@ -102,7 +101,7 @@ describe Appsignal::Transaction do
     end
 
     describe "complete_current!" do
-      before { Appsignal::Transaction.create('2', Appsignal::Transaction::HTTP_REQUEST, {}) }
+      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)
@@ -113,7 +112,7 @@ describe Appsignal::Transaction do
       end
 
       it "should still clear the transaction if there is an error" do
-        Appsignal::Transaction.current.should_receive(:complete).and_raise 'Error'
+        Appsignal::Transaction.current.should_receive(:complete).and_raise "Error"
 
         Appsignal::Transaction.complete_current!
 
@@ -163,9 +162,9 @@ describe Appsignal::Transaction do
   context "pausing" do
     describe "#pause!" do
       it "should change the pause flag to true" do
-        expect{
+        expect do
           transaction.pause!
-        }.to change(transaction, :paused).from(false).to(true)
+        end.to change(transaction, :paused).from(false).to(true)
       end
     end
 
@@ -173,23 +172,22 @@ describe Appsignal::Transaction do
       before { transaction.pause! }
 
       it "should change the pause flag to false" do
-        expect{
+        expect do
           transaction.resume!
-        }.to change(transaction, :paused).from(true).to(false)
+        end.to change(transaction, :paused).from(true).to(false)
       end
     end
 
     describe "#paused?" do
-
       it "should return the pause state" do
-        expect( transaction.paused? ).to be_false
+        expect(transaction.paused?).to be_false
       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_true
         end
       end
     end
@@ -200,8 +198,8 @@ describe Appsignal::Transaction do
       subject { transaction }
 
       its(:ext)                { should_not be_nil }
-      its(:transaction_id)     { should eq '1' }
-      its(:namespace)          { should eq 'http_request' }
+      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({}) }
@@ -212,7 +210,7 @@ describe Appsignal::Transaction do
         its([:params_method]) { should eq :params }
 
         context "with overridden options" do
-          let(:options) { {:params_method => :filtered_params} }
+          let(:options) { { :params_method => :filtered_params } }
 
           its([:params_method]) { should eq :filtered_params }
         end
@@ -221,32 +219,32 @@ describe Appsignal::Transaction do
 
     describe "#store" do
       it "should return an empty store when it's not already present" do
-        expect( transaction.store('test') ).to eql({})
+        expect(transaction.store("test")).to eql({})
       end
 
       it "should store changes to the store" do
-        transaction_store = transaction.store('test')
-        transaction_store['transaction'] = 'value'
+        transaction_store = transaction.store("test")
+        transaction_store["transaction"] = "value"
 
-        expect( transaction.store('test') ).to eql({'transaction' => 'value'})
+        expect(transaction.store("test")).to eql("transaction" => "value")
       end
     end
 
     describe "#set_tags" do
       it "should add tags to transaction" do
-        expect {
-          transaction.set_tags({'a' => 'b'})
-        }.to change(transaction, :tags).to({'a' => 'b'})
+        expect do
+          transaction.set_tags("a" => "b")
+        end.to change(transaction, :tags).to("a" => "b")
       end
     end
 
     describe "set_action" do
       it "should set the action in extension" do
-          transaction.ext.should_receive(:set_action).with(
-            'PagesController#show'
-          ).once
+        transaction.ext.should_receive(:set_action).with(
+          "PagesController#show"
+        ).once
 
-          transaction.set_action('PagesController#show')
+        transaction.set_action("PagesController#show")
       end
 
       it "should not set the action in extension when value is nil" do
@@ -258,26 +256,26 @@ describe Appsignal::Transaction do
 
     describe "#set_http_or_background_action" do
       context "for a hash with controller and action" do
-        let(:from) { {:controller => 'HomeController', :action => 'show'} }
+        let(:from) { { :controller => "HomeController", :action => "show" } }
 
         it "should set the action" do
-          transaction.should_receive(:set_action).with('HomeController#show')
+          transaction.should_receive(:set_action).with("HomeController#show")
         end
       end
 
       context "for a hash with just action" do
-        let(:from) { {:action => 'show'} }
+        let(:from) { { :action => "show" } }
 
         it "should set the action" do
-          transaction.should_receive(:set_action).with('show')
+          transaction.should_receive(:set_action).with("show")
         end
       end
 
       context "for a hash with class and method" do
-        let(:from) { {:class => 'Worker', :method => 'perform'} }
+        let(:from) { { :class => "Worker", :method => "perform" } }
 
         it "should set the action" do
-          transaction.should_receive(:set_action).with('Worker#perform')
+          transaction.should_receive(:set_action).with("Worker#perform")
         end
       end
 
@@ -304,19 +302,19 @@ describe Appsignal::Transaction do
 
         Appsignal.logger.should_receive(:warn).with("Queue start value 10 is too big")
 
-        lambda {
+        lambda do
           transaction.set_queue_start(10)
-        }.should_not raise_error
+        end.should_not raise_error
       end
     end
 
     describe "#set_http_or_background_queue_start" do
       context "for a http transaction" do
         let(:namespace) { Appsignal::Transaction::HTTP_REQUEST }
-        let(:env) { {'HTTP_X_REQUEST_START' => (fixed_time * 1000).to_s} }
+        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(13897836000)
+          transaction.should_receive(:set_queue_start).with(13_897_836_000)
 
           transaction.set_http_or_background_queue_start
         end
@@ -324,10 +322,10 @@ describe Appsignal::Transaction do
 
       context "for a background transaction" do
         let(:namespace) { Appsignal::Transaction::BACKGROUND_JOB }
-        let(:env) { {:queue_start => fixed_time} }
+        let(:env) { { :queue_start => fixed_time } }
 
         it "should set the queue start on the transaction" do
-          transaction.should_receive(:set_queue_start).with(1389783600000)
+          transaction.should_receive(:set_queue_start).with(1_389_783_600_000)
 
           transaction.set_http_or_background_queue_start
         end
@@ -337,73 +335,71 @@ describe Appsignal::Transaction do
     describe "#set_metadata" do
       it "should set the metdata in extension" do
         transaction.ext.should_receive(:set_metadata).with(
-          'request_method',
-          'GET'
+          "request_method",
+          "GET"
         ).once
 
-        transaction.set_metadata('request_method', 'GET')
+        transaction.set_metadata("request_method", "GET")
       end
 
       it "should not set the metdata in extension when value is nil" do
         transaction.ext.should_not_receive(:set_metadata)
 
-        transaction.set_metadata('request_method', nil)
+        transaction.set_metadata("request_method", nil)
       end
     end
 
     describe "set_sample_data" do
       it "should set the data" do
         transaction.ext.should_receive(:set_sample_data).with(
-          'params',
-          Appsignal::Utils.data_generate({"controller" => "blog_posts", "action" => "show", "id" => "1"})
+          "params",
+          Appsignal::Utils.data_generate("controller" => "blog_posts", "action" => "show", "id" => "1")
         ).once
 
         transaction.set_sample_data(
-          'params',
-          {
-            :controller => 'blog_posts',
-            :action     => 'show',
-            :id         => '1'
-          }
+          "params",
+          :controller => "blog_posts",
+          :action     => "show",
+          :id         => "1"
         )
       end
 
       it "should do nothing if the data cannot be converted to json" do
         transaction.ext.should_not_receive(:set_sample_data).with(
-          'params',
+          "params",
           kind_of(String)
         )
 
-        transaction.set_sample_data('params', 'string')
+        transaction.set_sample_data("params", "string")
       end
     end
 
     describe "#sample_data" do
       it "should sample data" do
         transaction.ext.should_receive(:set_sample_data).with(
-          'environment',
-          Appsignal::Utils.data_generate({
+          "environment",
+          Appsignal::Utils.data_generate(
             "CONTENT_LENGTH" => "0",
             "REQUEST_METHOD" => "GET",
             "SERVER_NAME" => "example.org",
             "SERVER_PORT" => "80",
             "PATH_INFO" => "/blog"
-          })
+          )
         ).once
         transaction.ext.should_receive(:set_sample_data).with(
-          'session_data',
+          "session_data",
           Appsignal::Utils.data_generate({})
         ).once
         transaction.ext.should_receive(:set_sample_data).with(
-          'params',
-          Appsignal::Utils.data_generate({"controller" => "blog_posts", "action" => "show", "id" => "1"})
+          "params",
+          Appsignal::Utils.data_generate("controller" => "blog_posts", "action" => "show", "id" => "1")
         ).once
         transaction.ext.should_receive(:set_sample_data).with(
-          'metadata',
-          Appsignal::Utils.data_generate({"key" => "value"})
+          "metadata",
+          Appsignal::Utils.data_generate("key" => "value")
         ).once
         transaction.ext.should_receive(:set_sample_data).with(
-          'tags',
+          "tags",
           Appsignal::Utils.data_generate({})
         ).once
 
@@ -411,21 +407,14 @@ describe Appsignal::Transaction do
       end
     end
 
-    describe '#set_error' do
+    describe "#set_error" do
       let(:env) { http_request_env_with_data }
-      let(:error) { double(:error, :message => 'test message', :backtrace => ['line 1']) }
+      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)
       end
 
-      it "should not add the error if it's in the ignored list" do
-        Appsignal.stub(:is_ignored_error? => true)
-        transaction.ext.should_not_receive(:set_error)
-
-        transaction.set_error(error)
-      end
-
       it "should not add the error if appsignal is not active" do
         Appsignal.stub(:active? => false)
         transaction.ext.should_not_receive(:set_error)
@@ -436,9 +425,9 @@ describe Appsignal::Transaction do
       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',
-            'test message',
-            Appsignal::Utils.data_generate(['line 1'])
+            "RSpec::Mocks::Mock",
+            "test message",
+            Appsignal::Utils.data_generate(["line 1"])
           )
 
           transaction.set_error(error)
@@ -446,17 +435,17 @@ describe Appsignal::Transaction do
       end
 
       context "when error message is nil" do
-        let(:error) { double(:error, :message => nil, :backtrace => ['line 1']) }
+        let(:error) { double(:error, :message => nil, :backtrace => ["line 1"]) }
 
         it "should not raise an error" do
-          expect{ transaction.set_error(error) }.to_not raise_error
+          expect { transaction.set_error(error) }.to_not raise_error
         end
 
         it "should set an error in the extension" do
           transaction.ext.should_receive(:set_error).with(
-            'RSpec::Mocks::Mock',
-            '',
-            Appsignal::Utils.data_generate(['line 1'])
+            "RSpec::Mocks::Mock",
+            "",
+            Appsignal::Utils.data_generate(["line 1"])
           )
 
           transaction.set_error(error)
@@ -475,32 +464,32 @@ describe Appsignal::Transaction do
     describe "#finish_event" do
       it "should finish the event in the extension" do
         transaction.ext.should_receive(:finish_event).with(
-          'name',
-          'title',
-          'body',
+          "name",
+          "title",
+          "body",
           1,
           0
         )
 
         transaction.finish_event(
-          'name',
-          'title',
-          'body',
+          "name",
+          "title",
+          "body",
           1
         )
       end
 
       it "should finish the event in the extension with nil arguments" do
         transaction.ext.should_receive(:finish_event).with(
-          'name',
-          '',
-          '',
+          "name",
+          "",
+          "",
           0,
           0
         )
 
         transaction.finish_event(
-          'name',
+          "name",
           nil,
           nil,
           nil
@@ -512,24 +501,24 @@ describe Appsignal::Transaction do
           .to receive(:internal_profiler)
           .and_return(FakeGCProfiler.new(0.12345))
 
-        transaction.finish_event('name', nil, nil, nil)
+        transaction.finish_event("name", nil, nil, nil)
       end
     end
 
     describe "#record_event" do
       it "should record the event in the extension" do
         transaction.ext.should_receive(:record_event).with(
-          'name',
-          'title',
-          'body',
+          "name",
+          "title",
+          "body",
           1000,
           1
         )
 
         transaction.record_event(
-          'name',
-          'title',
-          'body',
+          "name",
+          "title",
+          "body",
           1000,
           1
         )
@@ -537,15 +526,15 @@ describe Appsignal::Transaction do
 
       it "should finish the event in the extension with nil arguments" do
         transaction.ext.should_receive(:record_event).with(
-          'name',
-          '',
-          '',
+          "name",
+          "",
+          "",
           1000,
           0
         )
 
         transaction.record_event(
-          'name',
+          "name",
           nil,
           nil,
           1000,
@@ -557,19 +546,19 @@ 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')
+        stub.should_receive(:method_call).and_return("return value")
 
         transaction.should_receive(:start_event)
         transaction.should_receive(:finish_event).with(
-          'name',
-          'title',
-          'body',
+          "name",
+          "title",
+          "body",
           0
         )
 
-        transaction.instrument 'name', 'title', 'body' do
+        transaction.instrument "name", "title", "body" do
           stub.method_call
-        end.should eq 'return value'
+        end.should eq "return value"
       end
     end
 
@@ -584,13 +573,13 @@ describe Appsignal::Transaction do
       context "with a filled env" do
         let(:env) do
           {
-            :params => {:id => 1},
+            :params => { :id => 1 },
             :queue_start => 10
           }
         end
 
         its(:env) { should eq env }
-        its(:params) { should eq({:id => 1}) }
+        its(:params) { should eq(:id => 1) }
       end
     end
 
@@ -599,6 +588,18 @@ describe Appsignal::Transaction do
     describe "#background_queue_start" do
       subject { transaction.send(:background_queue_start) }
 
+      context "when request is nil" do
+        let(:request) { nil }
+
+        it { should eq nil }
+      end
+
+      context "when env is nil" do
+        before { expect(transaction.request).to receive(:env).and_return(nil) }
+
+        it { should eq nil }
+      end
+
       context "when queue start is nil" do
         it { should eq nil }
       end
@@ -606,7 +607,7 @@ describe Appsignal::Transaction do
       context "when queue start is set" do
         let(:env) { background_env_with_data }
 
-        it { should eq 1389783590000 }
+        it { should eq 1_389_783_590_000 }
       end
     end
 
@@ -616,8 +617,14 @@ describe Appsignal::Transaction do
       subject { transaction.send(:http_queue_start) }
 
       shared_examples "http queue start" do
+        context "when request is nil" do
+          let(:request) { nil }
+
+          it { should be_nil }
+        end
+
         context "when env is nil" do
-          before { transaction.request.stub(:env => nil) }
+          before { expect(transaction.request).to receive(:env).and_return(nil) }
 
           it { should be_nil }
         end
@@ -629,32 +636,32 @@ describe Appsignal::Transaction do
         end
 
         context "with the HTTP_X_REQUEST_START header set" do
-          let(:env) { {'HTTP_X_REQUEST_START' => "t=#{slightly_earlier_time_value}"} }
+          let(:env) { { "HTTP_X_REQUEST_START" => "t=#{slightly_earlier_time_value}" } }
 
-          it { should eq 1389783599600 }
+          it { should eq 1_389_783_599_600 }
 
           context "with unparsable content" do
-            let(:env) { {'HTTP_X_REQUEST_START' => 'something'} }
+            let(:env) { { "HTTP_X_REQUEST_START" => "something" } }
 
             it { should be_nil }
           end
 
           context "with some cruft" do
-            let(:env) { {'HTTP_X_REQUEST_START' => "t=#{slightly_earlier_time_value}aaaa"} }
+            let(:env) { { "HTTP_X_REQUEST_START" => "t=#{slightly_earlier_time_value}aaaa" } }
 
-            it { should eq 1389783599600 }
+            it { should eq 1_389_783_599_600 }
           end
 
           context "with a really low number" do
-            let(:env) { {'HTTP_X_REQUEST_START' => "t=100"} }
+            let(:env) { { "HTTP_X_REQUEST_START" => "t=100" } }
 
             it { should 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}"} }
+            let(:env) { { "HTTP_X_QUEUE_START" => "t=#{slightly_earlier_time_value}" } }
 
-            it { should eq 1389783599600 }
+            it { should eq 1_389_783_599_600 }
           end
         end
       end
@@ -688,7 +695,7 @@ describe Appsignal::Transaction do
       end
 
       context "when params method does not exist" do
-        let(:options) { {:params_method => :nonsense} }
+        let(:options) { { :params_method => :nonsense } }
 
         it { should be_nil }
       end
@@ -702,16 +709,16 @@ describe Appsignal::Transaction do
 
       context "with an array" do
         let(:request) do
-          Appsignal::Transaction::GenericRequest.new(background_env_with_data(:params => ['arg1', 'arg2']))
+          Appsignal::Transaction::GenericRequest.new(background_env_with_data(:params => ["arg1", "arg2"]))
         end
 
-        it { should eq ['arg1', 'arg2'] }
+        it { should 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 { should eq ["arg1", "arg2"] }
         end
       end
 
@@ -724,7 +731,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 })
+            subject.should eq(:foo => :bar)
           end
         end
 
@@ -737,10 +744,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
-            })
+            subject.should eq(:foo => "[FILTERED]", :baz => :bat)
           end
         end
       end
@@ -751,18 +755,26 @@ describe Appsignal::Transaction do
 
       subject { transaction.send(:sanitized_environment) }
 
+      context "when request is nil" do
+        let(:request) { nil }
+
+        it "returns nil" do
+          expect(subject).to be_nil
+        end
+      end
+
       context "when env is nil" do
-        before { transaction.request.stub(:env => nil) }
+        before { expect(transaction.request).to receive(:env).and_return(nil) }
 
         it { should be_nil }
       end
 
       context "when env is present" do
         let(:env) do
-          Hash.new.tap do |hash|
+          {}.tap do |hash|
             whitelisted_keys.each { |o| hash[o] = 1 } # use all whitelisted keys
             hash[whitelisted_keys] = nil # don't add if nil
-            hash[:not_whitelisted] = 'I will be sanitized'
+            hash[:not_whitelisted] = "I will be sanitized"
           end
         end
 
@@ -770,17 +782,25 @@ describe Appsignal::Transaction do
       end
     end
 
-    describe '#sanitized_session_data' do
+    describe "#sanitized_session_data" do
       subject { transaction.send(:sanitized_session_data) }
 
-      context "when env is nil" do
-        before { transaction.request.stub(:session => nil) }
+      context "when request is nil" do
+        let(:request) { nil }
+
+        it "returns nil" do
+          expect(subject).to be_nil
+        end
+      end
+
+      context "when session is nil" do
+        before { expect(transaction.request).to receive(:session).and_return(nil) }
 
         it { should be_nil }
       end
 
-      context "when env is empty" do
-        before { transaction.request.stub(:session => {}) }
+      context "when session is empty" do
+        before { expect(transaction.request).to receive(:session).and_return({}) }
 
         it { should eq({}) }
       end
@@ -794,13 +814,13 @@ describe Appsignal::Transaction do
       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, :session => { :foo => :bar })
           transaction.stub_chain(:request, :fullpath => :bar)
         end
 
         it "passes the session data into the params sanitizer" do
-          Appsignal::Utils::ParamsSanitizer.should_receive(:sanitize).with({:foo => :bar}).
-            and_return(:sanitized_foo)
+          Appsignal::Utils::ParamsSanitizer.should_receive(:sanitize).with(:foo => :bar)
+            .and_return(:sanitized_foo)
           subject.should eq :sanitized_foo
         end
 
@@ -813,24 +833,29 @@ describe Appsignal::Transaction do
             end
 
             it "should return an session hash" do
-              Appsignal::Utils::ParamsSanitizer.should_receive(:sanitize).with({'foo' => :bar}).
-                and_return(:sanitized_foo)
+              Appsignal::Utils::ParamsSanitizer.should_receive(:sanitize).with("foo" => :bar)
+                .and_return(:sanitized_foo)
               subject
             end
 
             def action_dispatch_session
-              store = Class.new {
-                def load_session(env); [1, {:foo => :bar}]; end
-                def session_exists?(env); true; end
-              }.new
-              ActionDispatch::Request::Session.create(store, ActionDispatch::Request.new('rack.input' => StringIO.new), {})
+              store = Class.new do
+                def load_session(_env)
+                  [1, { :foo => :bar }]
+                end
+
+                def session_exists?(_env)
+                  true
+                end
+              end.new
+              ActionDispatch::Request::Session.create(store, ActionDispatch::Request.new("rack.input" => StringIO.new), {})
             end
           end
         end
 
         context "when skipping session data" do
           before do
-            Appsignal.config = {:skip_session_data => true}
+            Appsignal.config = { :skip_session_data => true }
           end
 
           it "does not pass the session data into the params sanitizer" do
@@ -844,33 +869,37 @@ describe Appsignal::Transaction do
     describe "#metadata" do
       subject { transaction.send(:metadata) }
 
+      context "when request is nil" do
+        let(:request) { nil }
+
+        it { should be_nil }
+      end
+
       context "when env is nil" do
-        before { transaction.request.stub(:env => nil) }
+        before { expect(transaction.request).to receive(:env).and_return(nil) }
 
         it { should be_nil }
       end
 
       context "when env is present" do
-        let(:env) { {:metadata => {:key => 'value'}} }
+        let(:env) { { :metadata => { :key => "value" } } }
 
         it { should eq env[:metadata] }
       end
     end
 
-    describe '#sanitized_tags' do
+    describe "#sanitized_tags" do
       before do
         transaction.set_tags(
-          {
-            :valid_key => 'valid_value',
-            'valid_string_key' => 'valid_value',
-            :both_symbols => :valid_value,
-            :integer_value => 1,
-            :hash_value => {'invalid' => 'hash'},
-            :array_value => ['invalid', 'array'],
-            :to_long_value => SecureRandom.urlsafe_base64(101),
-            :object => Object.new,
-            SecureRandom.urlsafe_base64(101) => 'to_long_key'
-          }
+          :valid_key => "valid_value",
+          "valid_string_key" => "valid_value",
+          :both_symbols => :valid_value,
+          :integer_value => 1,
+          :hash_value => { "invalid" => "hash" },
+          :array_value => ["invalid", "array"],
+          :to_long_value => SecureRandom.urlsafe_base64(101),
+          :object => Object.new,
+          SecureRandom.urlsafe_base64(101) => "to_long_key"
         )
       end
       subject { transaction.send(:sanitized_tags).keys }
@@ -878,7 +907,7 @@ describe Appsignal::Transaction do
       it "should only return whitelisted data" do
         should =~ [
           :valid_key,
-          'valid_string_key',
+          "valid_string_key",
           :both_symbols,
           :integer_value
         ]
@@ -886,10 +915,10 @@ describe Appsignal::Transaction do
     end
 
     describe "#cleaned_backtrace" do
-      subject { transaction.send(:cleaned_backtrace, ['line 1', 'line 2']) }
+      subject { transaction.send(:cleaned_backtrace, ["line 1", "line 2"]) }
 
       it "returns the backtrace" do
-        expect(subject).to eq ['line 1', 'line 2']
+        expect(subject).to eq ["line 1", "line 2"]
       end
 
       if rails_present?
@@ -898,7 +927,7 @@ describe Appsignal::Transaction do
             ::Rails.backtrace_cleaner.add_filter do |line|
               line.tr("2", "?")
             end
-            expect(subject).to eq ['line 1', 'line ?']
+            expect(subject).to eq ["line 1", "line ?"]
           end
         end
       end
@@ -909,22 +938,22 @@ describe Appsignal::Transaction do
     subject { Appsignal::Transaction::NilTransaction.new }
 
     it "should have method stubs" do
-      lambda {
+      lambda do
         subject.complete
         subject.pause!
         subject.resume!
         subject.paused?
         subject.store(:key)
         subject.set_tags(:tag => 1)
-        subject.set_action('action')
+        subject.set_action("action")
         subject.set_http_or_background_action
         subject.set_queue_start(1)
         subject.set_http_or_background_queue_start
-        subject.set_metadata('key', 'value')
-        subject.set_sample_data('key', 'data')
+        subject.set_metadata("key", "value")
+        subject.set_sample_data("key", "data")
         subject.sample_data
-        subject.set_error('a')
-      }.should_not raise_error
+        subject.set_error("a")
+      end.should_not raise_error
     end
   end
 end