appsignal 0.11.18 → 0.12.beta.0

data/spec/lib/appsignal/transaction_spec.rb

@@ -11,48 +11,90 @@ describe Appsignal::Transaction do
     start_agent
   end
 
-  describe '.create' do
-    subject { Appsignal::Transaction.create('1', {}) }
+  let(:time)        { Time.at(fixed_time) }
+  let(:transaction) { Appsignal::Transaction.create('1', {}) }
 
-    it 'should add the request id to the thread local' do
-      subject
-      Thread.current[:appsignal_transaction_id].should == '1'
+  before { Timecop.freeze(time) }
+  after  { Timecop.return }
+
+  context "class methods" do
+    describe '.create' do
+      subject { Appsignal::Transaction.create('1', {}) }
+
+      it 'should add the transaction to thread local' do
+        Appsignal::Extension.should_receive(:start_transaction).with('1')
+        subject
+        Thread.current[:appsignal_transaction].should == subject
+      end
+
+      it "should create a transaction" do
+        subject.should be_a Appsignal::Transaction
+        subject.request_id.should == '1'
+      end
     end
 
-    it "should create a transaction" do
-      subject.should be_a Appsignal::Transaction
-      subject.request_id.should == '1'
+    describe '.current' do
+      let(:transaction) { Appsignal::Transaction.create('1', {}) }
+      before { transaction }
+      subject { Appsignal::Transaction.current }
+
+      it 'should return the correct transaction' do
+        should == transaction
+      end
     end
-  end
 
-  describe '.current' do
-    let(:transaction) { Appsignal::Transaction.create('1', {}) }
-    before { transaction }
-    subject { Appsignal::Transaction.current }
+    describe "complete_current!" do
+      before { Thread.current[:appsignal_transaction] = nil }
+
+      context "with a current transaction" do
+        before { Appsignal::Transaction.create('2', {}) }
+
+        it "should complete the current transaction and set the thread appsignal_transaction to nil" do
+          Appsignal::Extension.should_receive(:finish_transaction).with('2')
+
+          Appsignal::Transaction.complete_current!
 
-    it 'should return the correct transaction' do
-      should eq transaction
+          Thread.current[:appsignal_transaction].should be_nil
+        end
+      end
+
+      context "without a current transaction" do
+        it "should not raise an error" do
+          Appsignal::Transaction.complete_current!
+        end
+      end
     end
   end
 
-  describe "complete_current!" do
-    before { Thread.current[:appsignal_transaction_id] = nil }
+  describe "#pause!" do
+    it "should change the pause flag to true" do
+      expect{
+        transaction.pause!
+      }.to change(transaction, :paused).from(false).to(true)
+    end
+  end
 
-    context "with a current transaction" do
-      before { Appsignal::Transaction.create('2', {}) }
+  describe "#resume!" do
+    before { transaction.pause! }
 
-      it "should complete the current transaction and reset the thread appsignal_transaction_id" do
-        Appsignal::Transaction.current.should_receive(:complete!)
+    it "should change the pause flag to false" do
+      expect{
+        transaction.resume!
+      }.to change(transaction, :paused).from(true).to(false)
+    end
+  end
 
-        Appsignal::Transaction.complete_current!
+  describe "#paused?" do
 
-        Thread.current[:appsignal_transaction_id].should be_nil
-      end
+    it "should return the pasue state" do
+      expect( transaction.paused? ).to be_false
     end
 
-    context "without a current transaction" do
-      it "should not raise an error" do
-        Appsignal::Transaction.complete_current!
+    context "when paused" do
+      before { transaction.pause! }
+
+      it "should return the pasue state" do
+        expect( transaction.paused? ).to be_true
       end
     end
   end
@@ -68,85 +110,21 @@ describe Appsignal::Transaction do
     end
     let(:transaction) { Appsignal::Transaction.create('3', env) }
 
-    it "should add the transaction to the list" do
-      transaction
-      Appsignal.transactions['3'].should == transaction
+    context "initialization" do
+      subject { transaction }
+
+      its(:request_id)         { should == '3' }
+      its(:root_event_payload) { should be_nil }
+      its(:exception)          { should be_nil }
+      its(:env)                { should == env }
+      its(:tags)               { should == {} }
+      its(:queue_start)        { should == -1 }
     end
 
     describe '#request' do
       subject { transaction.request }
 
       it { should be_a ::Rack::Request }
-
-      context "without env" do
-        let(:env) { nil }
-
-        it { should be_nil }
-      end
-    end
-
-    describe '#set_process_action_event' do
-      before { transaction.set_process_action_event(process_action_event) }
-
-      let(:process_action_event) { notification_event }
-
-      it 'should add a process action event' do
-        transaction.process_action_event.name.should == process_action_event.name
-        transaction.process_action_event.payload.should == process_action_event.payload
-      end
-
-      it "should set the action" do
-        transaction.action.should == 'BlogPostsController#show'
-      end
-
-      it "should set the kind" do
-        transaction.kind.should == 'http_request'
-      end
-
-      it "should call set_http_queue_start" do
-        transaction.queue_start.should_not be_nil
-      end
-
-      context "if there is no controller" do
-        before do
-          process_action_event.payload[:action] = 'GET /items/:id'
-          process_action_event.payload.delete(:controller)
-          transaction.set_process_action_event(process_action_event)
-        end
-
-        it "should set the action without a #" do
-          transaction.action.should == 'GET /items/:id'
-        end
-      end
-    end
-
-    describe "set_perform_job_event" do
-      before { transaction.set_perform_job_event(perform_job_event) }
-
-      let(:payload) { create_background_payload }
-      let(:perform_job_event) do
-        notification_event(
-          :name => 'perform_job.delayed_job',
-          :payload => payload
-        )
-      end
-
-      it 'should add a perform job event' do
-        transaction.process_action_event.name.should == perform_job_event.name
-        transaction.process_action_event.payload.should == perform_job_event.payload
-      end
-
-      it "should set the action" do
-        transaction.action.should == 'BackgroundJob#perform'
-      end
-
-      it "should set the kind" do
-        transaction.kind.should == 'background_job'
-      end
-
-      it "should set call set_background_queue_start" do
-        transaction.queue_start.should_not be_nil
-      end
     end
 
     describe "#set_tags" do
@@ -157,510 +135,291 @@ describe Appsignal::Transaction do
       end
     end
 
-    describe '#add_event' do
-      let(:event) { double(:event, :name => 'test') }
-
-      it 'should add an event' do
-        expect {
-          transaction.add_event(event)
-        }.to change(transaction, :events).to([event])
-      end
-
-      context "when paused" do
-        before { transaction.pause! }
-
-        it 'should add an event' do
-          expect {
-            transaction.add_event(event)
-          }.to_not change(transaction, :events)
-        end
-      end
-    end
-
-    describe "#pause!" do
-      it "should change the pause flag to true" do
-        expect{
-          transaction.pause!
-        }.to change(transaction, :paused).from(false).to(true)
-      end
-    end
-
-    describe "#resume!" do
-      before { transaction.pause! }
-
-      it "should change the pause flag to false" do
-        expect{
-          transaction.resume!
-        }.to change(transaction, :paused).from(true).to(false)
-      end
-    end
-
-    context "using exceptions" do
-      let(:exception) do
-        double(
-          :exception,
-          :class => double(:name => 'test'),
-          :message   => 'Broken',
-          :backtrace => [
-            File.join(project_fixture_path, 'app/controllers/somethings_controller.rb:10').to_s,
-            '/user/local/ruby/path.rb:8'
-          ]
-        )
-      end
+    describe '#set_root_event' do
+      context "for a process_action event" do
+        let(:name)    { 'process_action.action_controller' }
+        let(:payload) { create_payload }
+
+        it "should set the meta data in the transaction and native" do
+          Appsignal::Extension.should_receive(:set_transaction_basedata).with(
+            '3',
+            'http_request',
+            'BlogPostsController#show',
+            kind_of(Integer)
+          )
 
-      describe '#add_exception' do
-        it 'should add an exception', :if => rails_present? do
-          if Gem::Version.new(Rails.version) >= Gem::Version.new('4.2.0')
-            expect {
-              transaction.add_exception(exception)
-            }.to change(transaction, :exception).to({
-              :exception => 'test',
-              :message   => 'Broken',
-              :backtrace => [
-                'spec/support/project_fixture/app/controllers/somethings_controller.rb:10',
-                '/user/local/ruby/path.rb:8'
-              ]
-            })
-          else
-            expect {
-              transaction.add_exception(exception)
-            }.to change(transaction, :exception).to({
-              :exception => 'test',
-              :message   => 'Broken',
-              :backtrace => [
-                'app/controllers/somethings_controller.rb:10',
-                '/user/local/ruby/path.rb:8'
-              ]
-            })
+          metadata = {
+            'path'           => '/blog',
+            'request_format' => 'html',
+            'request_method' => 'GET',
+            'status'         => '200'
+          }
+          metadata.each do |key, value|
+            transaction.should_receive(:set_metadata).with(key, value).once
           end
-        end
 
-        it 'should add an exception', :if => !rails_present? do
-          expect {
-            transaction.add_exception(exception)
-          }.to change(transaction, :exception).to({
-            :exception => 'test',
-            :message   => 'Broken',
-            :backtrace => [
-              File.join(project_fixture_path, 'app/controllers/somethings_controller.rb:10'),
-              '/user/local/ruby/path.rb:8'
-            ]
-          })
-        end
-      end
-
-      describe "#exception?" do
-        subject { transaction.exception? }
-
-        context "without an exception" do
-          it { should be_false }
-        end
+          transaction.set_root_event(name, payload)
 
-        context "without an exception" do
-          before { transaction.add_exception(exception) }
-
-          it { should be_true }
+          transaction.root_event_payload.should == payload
+          transaction.action.should == 'BlogPostsController#show'
+          transaction.kind.should == 'http_request'
+          transaction.queue_start.should be_kind_of(Integer)
         end
       end
-    end
 
-    describe '#slow_request?' do
-      let(:start) { Time.now }
-      subject { transaction.slow_request? }
+      context "for a perform_job event" do
+        let(:name)    { 'perform_job.delayed_job' }
+        let(:payload) { create_background_payload }
 
-      context "duration" do
-        before do
-          transaction.set_process_action_event(
-            notification_event(:start => start, :ending => start + duration)
+        it "should set the meta data in the transaction and native" do
+          Appsignal::Extension.should_receive(:set_transaction_basedata).with(
+            '3',
+            'background_job',
+            'BackgroundJob#perform',
+            kind_of(Integer)
           )
-        end
-
-        context "when it reasonably fast" do
-          let(:duration) { 0.199 } # in seconds
-
-          it { should be_false }
-        end
-
-        context "when the request took too long" do
-          let(:duration) { 0.201 } # in seconds
-
-          it { should be_true }
-        end
-      end
 
-      context "when process action event is empty" do
-        before { transaction.set_process_action_event(nil) }
+          transaction.set_root_event(name, payload)
 
-        it { should be_false }
-      end
-
-      context "when process action event does not have a payload" do
-        let(:event) { notification_event }
-        before do
-          event.instance_variable_set(:@payload, nil)
-          transaction.set_process_action_event(event)
+          transaction.root_event_payload.should == payload
+          transaction.action.should == 'BackgroundJob#perform'
+          transaction.kind.should == 'background_job'
+          transaction.queue_start.should be_kind_of(Integer)
         end
-
-        it { should be_false }
       end
     end
 
-    describe "#slower?" do
-      context "comparing to a slower transaction" do
-        subject { regular_transaction.slower?(slow_transaction) }
+    describe "#set_metadata" do
+      it "should set the metdata in native" do
+        Appsignal::Extension.should_receive(:set_transaction_metadata).with(
+          '3',
+          'request_method',
+          'GET'
+        ).once
 
-        it { should be_false }
+        transaction.set_metadata('request_method', 'GET')
       end
 
-      context "comparing to a faster transaction" do
-        subject { slow_transaction.slower?(regular_transaction) }
+      it "should set the metdata in native when value is nil" do
+        Appsignal::Extension.should_not_receive(:set_transaction_metadata)
 
-        it { should be_true }
+        transaction.set_metadata('request_method', nil)
       end
     end
 
-    describe "clear_events!" do
-      let(:transaction) { slow_transaction }
+    describe '#set_error' do
+      let(:error) { double(:error, :message => 'test message', :backtrace => ['line 1']) }
 
-      it "should remove events from the transaction" do
-        expect {
-          transaction.clear_events!
-        }.to change(transaction.events, :length).from(1).to(0)
+      it "should also respond to add_exception for backwords compatibility" do
+        transaction.should respond_to(:add_exception)
       end
-    end
-
-    describe "#truncate!" do
-      subject { slow_transaction }
-      before  do
-        subject.set_tags('a' => 'b')
-        subject.sanitized_environment[:foo]  = 'bar'
-        subject.sanitized_session_data[:foo] = 'bar'
-        subject.sanitized_params[:foo]       = 'bar'
-      end
-
-      it "should clear the process action payload and events" do
-        subject.truncate!
-
-        subject.process_action_event.payload.should be_empty
-        subject.events.should be_empty
-        subject.tags.should be_empty
-
-        subject.sanitized_environment.should be_empty
-        subject.sanitized_session_data.should be_empty
-        subject.sanitized_params.should be_empty
-
-        subject.truncated?.should be_true
-      end
-
-      it "should not truncate twice" do
-        subject.process_action_event.should_receive(:truncate!).once
-        subject.events.should_receive(:clear).once
-
-        subject.truncate!
-        subject.truncate!
-      end
-    end
-
-    describe "#convert_values_to_primitives!" do
-      let(:transaction) { slow_transaction }
-      let(:action_event) { transaction.process_action_event }
-      let(:event) { transaction.events.first }
-      let(:weird_class) { Class.new }
-      let(:smash) { Smash.new.merge!(:foo => 'bar') }
-
-      context "with values that need to be converted" do
-        context "process action event payload" do
-          subject { action_event.payload }
-          before do
-            action_event.payload.clear
-            action_event.payload.merge!(
-              :model => {:with => [:weird, weird_class]},
-            )
-            transaction.convert_values_to_primitives!
-          end
-
-          it "should convert all payloads to primitives" do
-            should == {
-              :model => {:with => [:weird, '#<Class>']},
-            }
-          end
-        end
-
-        context "payload of events" do
-          subject { event.payload }
-          before do
-            event.payload.clear
-            event.payload.merge!(
-              :weird => weird_class,
-              :smash => smash
-              )
-            transaction.convert_values_to_primitives!
-          end
-
-          its([:weird]) { should be_a(String) }
-          its([:weird]) { should eql("#<Class>") }
-          its([:smash]) { should == {:foo => 'bar'} }
-        end
-      end
-
-      context "without values that need to be converted" do
-        subject { transaction.convert_values_to_primitives! }
-
-        it "doesn't change the action event payload" do
-          before = action_event.payload.dup
-          subject
-          action_event.payload.should == before
-        end
-
-        it " doesn't change the event payloads" do
-          before = event.payload.dup
-          subject
-          event.payload.should == before
-        end
-
-        it "should not covert to primitives twice" do
-          transaction.convert_values_to_primitives!
-          transaction.have_values_been_converted_to_primitives?.should be_true
 
-          Appsignal::ParamsSanitizer.should_not_receive(:sanitize!)
-          transaction.convert_values_to_primitives!
-        end
-      end
-    end
-
-    describe "#type" do
-      context "with a regular transaction" do
-        subject { regular_transaction.type }
-
-        it { should == :regular_request }
-      end
-
-      context "with a slow transaction" do
-        subject { slow_transaction.type }
-
-        it { should == :slow_request }
-      end
-
-      context "with an exception transaction" do
-        subject { transaction_with_exception.type }
-
-        it { should == :exception }
-      end
-    end
-
-    describe '#to_hash' do
-      subject { transaction.to_hash }
-
-      it { should be_instance_of Hash }
-    end
-
-    describe '#complete!' do
-      let(:event) { double(:event) }
-      let(:exception) do
-        double(
-          :exception,
-          :class => double(:name => 'test'),
-          :message   => 'Broken',
-          :backtrace => [
-            'app/controllers/somethings_controller.rb:10',
-            '/user/local/ruby/path.rb:8'
-          ]
+      it "should set an error and it's data in native" do
+        Appsignal::Extension.should_receive(:set_transaction_error).with(
+          '3',
+          'RSpec::Mocks::Mock',
+          'test message'
         )
-      end
-      before do
-        Appsignal::IPC.stub(:current => nil)
-        transaction.set_process_action_event(notification_event)
-      end
-
-      it 'should remove transaction from the list' do
-        expect { transaction.complete! }.
-          to change(Appsignal.transactions, :length).by(-1)
-      end
-
-      context 'enqueueing' do
-        context 'sanity check' do
-          specify { Appsignal.should respond_to(:enqueue) }
-        end
-
-        context 'without events and without exception' do
-          it 'should add transaction to the agent' do
-            Appsignal.should_receive(:enqueue).with(transaction)
-          end
-        end
-
-        context 'with events' do
-          before { transaction.add_event(event) }
-
-          it 'should add transaction to the agent' do
-            Appsignal.should_receive(:enqueue).with(transaction)
-          end
+        Appsignal::Extension.should_receive(:set_transaction_error_data).with(
+          '3',
+          'environment',
+          "{\"SERVER_NAME\":\"localhost\",\"HTTP_X_REQUEST_START\":\"1000000\",\"HTTP_USER_AGENT\":\"IE6\"}"
+        ).once
+        Appsignal::Extension.should_receive(:set_transaction_error_data).with(
+          '3',
+          'session_data',
+          "{}"
+        ).once
+        Appsignal::Extension.should_receive(:set_transaction_error_data).with(
+          '3',
+          'backtrace',
+          "[\"line 1\"]"
+        ).once
+        Appsignal::Extension.should_receive(:set_transaction_error_data).with(
+          '3',
+          'tags',
+          "{}"
+        ).once
+
+        transaction.set_error(error)
+      end
+
+      context "with root event payload" do
+        before do
+          transaction.set_root_event('process_action.action_controller', create_payload)
         end
 
-        context 'with exception' do
-          before { transaction.add_exception(exception) }
+        it "should also set params" do
+          Appsignal::Extension.should_receive(:set_transaction_error_data).with(
+            '3',
+            'params',
+            '{"controller":"blog_posts","action":"show","id":"1"}'
+          ).once
+          Appsignal::Extension.should_receive(:set_transaction_error_data).with(
+            '3',
+            kind_of(String),
+            kind_of(String)
+          ).exactly(4).times
 
-          it 'should add transaction to the agent' do
-            Appsignal.should_receive(:enqueue).with(transaction)
-          end
+          transaction.set_error(error)
         end
-
-        after { transaction.complete! }
       end
 
-      context 'when using IPC' do
+      context "with a non-json convertable type" do
         before do
-          Appsignal::IPC::Client.start
-          transaction.stub(:convert_values_to_primitives! => true)
-        end
-        after do
-          Appsignal::IPC::Client.stop
+          transaction.stub(:sanitized_params => 'a string')
         end
 
-        it "should convert to primitves and send itself trough the pipe" do
-          transaction.should_receive(:convert_values_to_primitives!)
-          Appsignal::IPC::Client.should_receive(:enqueue).with(transaction)
-        end
+        it "should skip the field" do
+          Appsignal::Extension.should_not_receive(:set_transaction_error_data).with(
+            '3',
+            'params',
+            kind_of(String)
+          )
+          Appsignal::Extension.should_receive(:set_transaction_error_data).with(
+            '3',
+            kind_of(String),
+            kind_of(String)
+          ).exactly(4).times
 
-        after { transaction.complete! }
+          transaction.set_error(error)
+        end
       end
     end
 
+    # protected
+
     describe "#set_background_queue_start" do
       before do
-        transaction.stub(:process_action_event =>
-          notification_event(
-            :name => 'perform_job.delayed_job',
-            :payload => payload
-          )
-        )
-        transaction.set_background_queue_start
+        transaction.stub(:root_event_payload => payload)
+        transaction.send(:set_background_queue_start)
       end
+
       subject { transaction.queue_start }
 
       context "when queue start is nil" do
         let(:payload) { create_background_payload(:queue_start => nil) }
 
-        it { should be_nil }
+        it { should == -1 }
       end
 
       context "when queue start is set" do
         let(:payload) { create_background_payload }
 
-        it { should == 1389783590.0 }
+        it { should == 1389783590000 }
       end
     end
 
-    describe "#set_http_queue_start" do
-      let(:slightly_earlier_time) { fixed_time - 0.4 }
-      let(:slightly_earlier_time_value) { (slightly_earlier_time * factor).to_i }
-      before { transaction.set_http_queue_start }
-      subject { transaction.queue_start }
+    describe "#sanitized_params" do
+      subject { transaction.send(:sanitized_params) }
 
-      shared_examples "http queue start" do
-        context "without env" do
-          let(:env) { nil }
+      context "without a root event payload" do
+        it { should be_nil }
+      end
 
-          it { should be_nil }
-        end
+      context "with a root event payload" do
+        before { transaction.stub(:root_event_payload => create_payload) }
 
-        context "with no relevant header set" do
-          let(:env) { {} }
+        it "should call the params sanitizer" do
+          Appsignal::ParamsSanitizer.should_receive(:sanitize).with(kind_of(Hash)).and_return({:id => 1})
 
-          it { should be_nil }
+          subject.should == {:id => 1}
         end
+      end
+    end
 
-        context "with the HTTP_X_REQUEST_START header set" do
-          let(:env) { {'HTTP_X_REQUEST_START' => "t=#{slightly_earlier_time_value}"} }
-
-          it { should == 1389783599.6 }
-
-          context "with unparsable content" do
-            let(:env) { {'HTTP_X_REQUEST_START' => 'something'} }
-
-            it { should be_nil }
-          end
+    describe "#sanitized_environment" do
+      let(:whitelisted_keys) { Appsignal::Transaction::ENV_METHODS }
+      let(:transaction) { Appsignal::Transaction.create('1', env) }
 
-          context "with some cruft" do
-            let(:env) { {'HTTP_X_REQUEST_START' => "t=#{slightly_earlier_time_value}aaaa"} }
+      subject { transaction.send(:sanitized_environment) }
 
-            it { should == 1389783599.6 }
-          end
+      context "when env is nil" do
+        let(:env) { nil }
 
-          context "with the alternate HTTP_X_QUEUE_START header set" do
-            let(:env) { {'HTTP_X_QUEUE_START' => "t=#{slightly_earlier_time_value}"} }
+        it { should be_nil }
+      end
 
-            it { should == 1389783599.6 }
+      context "when env is present" do
+        let(:env) do
+          Hash.new.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'
           end
         end
-      end
-
-      context "time in miliseconds" do
-        let(:factor) { 1_000 }
 
-        it_should_behave_like "http queue start"
-      end
-
-      context "time in microseconds" do
-        let(:factor) { 1_000_000 }
-
-        it_should_behave_like "http queue start"
+        its(:keys) { should =~ whitelisted_keys[0, whitelisted_keys.length] }
       end
     end
 
-    # protected
-
-    describe '#add_sanitized_context!' do
-      subject { transaction.send(:add_sanitized_context!) }
+    describe '#sanitized_session_data' do
+      subject { transaction.send(:sanitized_session_data) }
 
-      context "for a http request" do
-        before { transaction.stub(:kind => 'http_request') }
+      context "when env is nil" do
+       let(:transaction) { Appsignal::Transaction.create('1', nil) }
 
-        it "should call sanitize_environment!, sanitize_session_data! and sanitize_tags!" do
-          transaction.should_receive(:sanitize_environment!)
-          transaction.should_receive(:sanitize_session_data!)
-          transaction.should_receive(:sanitize_tags!)
-          transaction.should_receive(:sanitize_params!)
-          subject
-        end
+        it { should be_nil }
       end
 
-      context "for a non-web request" do
-        before { transaction.stub(:kind => 'background_job') }
+      context "when env is empty" do
+       let(:transaction) { Appsignal::Transaction.create('1', {}) }
 
-        it "should not call sanitize_session_data!" do
-          transaction.should_receive(:sanitize_environment!)
-          transaction.should_not_receive(:sanitize_session_data!)
-          transaction.should_receive(:sanitize_tags!)
-          transaction.should_receive(:sanitize_params!)
-          subject
-        end
+        it { should == {} }
       end
 
-      specify { expect { subject }.to change(transaction, :env).to(nil) }
-    end
-
-    describe '#sanitize_environment!' do
-      let(:whitelisted_keys) { Appsignal::Transaction::ENV_METHODS }
-      let(:transaction) { Appsignal::Transaction.create('1', env) }
-      let(:env) do
-        Hash.new.tap do |hash|
-          whitelisted_keys.each { |o| hash[o] = 1 } # use all whitelisted keys
-          hash[:not_whitelisted] = 'I will be sanitized'
+      context "when there is a session" do
+       let(:transaction) { Appsignal::Transaction.create('1', {}) }
+        before do
+          transaction.should respond_to(:request)
+          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::ParamsSanitizer.should_receive(:sanitize).with({:foo => :bar}).
+            and_return(:sanitized_foo)
+          subject.should == :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)
+            end
+
+            it "should return an session hash" do
+              Appsignal::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, {}, {})
+            end
+          end
         end
       end
-      subject { transaction.sanitized_environment }
-      before { transaction.send(:sanitize_environment!) }
 
-      its(:keys) { should =~ whitelisted_keys }
-
-      context "when env is nil" do
-        let(:env) { nil }
+      context "when skipping session data" do
+        before do
+          Appsignal.config = {:skip_session_data => true}
+        end
 
-        it { should be_empty }
+        it "does not pass the session data into the params sanitizer" do
+          Appsignal::ParamsSanitizer.should_not_receive(:sanitize)
+          subject.should be_nil
+        end
       end
     end
 
-    describe '#sanitize_tags!' do
+    describe '#sanitized_tags' do
       let(:transaction) { Appsignal::Transaction.create('1', {}) }
       before do
         transaction.set_tags(
@@ -676,9 +435,8 @@ describe Appsignal::Transaction do
             SecureRandom.urlsafe_base64(101) => 'to_long_key'
           }
         )
-        transaction.send(:sanitize_tags!)
       end
-      subject { transaction.tags.keys }
+      subject { transaction.send(:sanitized_tags).keys }
 
       it "should only return whitelisted data" do
         should =~ [
@@ -690,102 +448,12 @@ describe Appsignal::Transaction do
       end
     end
 
-    describe '#sanitize_session_data!' do
-      subject { transaction.send(:sanitize_session_data!) }
-      before do
-        transaction.should respond_to(:request)
-        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::ParamsSanitizer.should_receive(:sanitize).with({:foo => :bar}).
-          and_return(:sanitized_foo)
-        subject
-        transaction.sanitized_session_data.should == :sanitized_foo
-      end
-
-      it "sets the fullpath of the request" do
-        expect { subject }.to change(transaction, :fullpath).to(:bar)
-      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)
-          end
-
-          it "should return an session hash" do
-            Appsignal::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, {}, {})
-          end
-        end
-      end
-
-      context "when skipping session data" do
-        before do
-          Appsignal.config = {:skip_session_data => true}
-        end
-
-        it "does not pass the session data into the params sanitizer" do
-          Appsignal::ParamsSanitizer.should_not_receive(:sanitize)
-          subject
-          transaction.sanitized_session_data.should == {}
-        end
-      end
-
-      context "without a request" do
-        before do
-          transaction.stub(:request => nil)
-        end
-
-        it "does not pass the session data into the params sanitizer" do
-          Appsignal::ParamsSanitizer.should_not_receive(:sanitize)
-          subject
-          transaction.sanitized_session_data.should == {}
-        end
-      end
-    end
-
-    describe '#sanitize_params!' do
-      let(:params) { {:foo => 'bar'} }
-      let(:transaction) do
-        Appsignal::Transaction.create('1', {}, :params => params)
-      end
-      before  { Appsignal.config = {:send_params => true} }
-      subject { transaction.sanitized_params }
-
-      it "should call the params sanitizer and set sanitized params" do
-        Appsignal::ParamsSanitizer.should_receive(:sanitize)
-          .with(params)
-          .and_return({'foo' => 'bar'})
+    describe "#cleaned_backtrace" do
+      subject { transaction.send(:cleaned_backtrace, ['line 1']) }
 
-        transaction.send(:sanitize_params!)
+      it { should == ['line 1'] }
 
-        should == {'foo' => 'bar'}
-      end
-
-      context "when skipping session data" do
-        before { Appsignal.config = {:send_params => false} }
-
-        it "should not pass data to the params sanitizer" do
-          Appsignal::ParamsSanitizer.should_not_receive(:sanitize)
-          transaction.send(:sanitize_params!)
-
-          should == {}
-        end
-      end
+      pending "calls Rails backtrace cleaner if Rails is present"
     end
   end
 end