rollbar 2.10.0 → 2.11.0

data/lib/rollbar/plugins/thread.rb

@@ -0,0 +1,13 @@
+Rollbar.plugins.define('thread') do
+  execute do
+    Thread.class_eval do
+      def initialize_with_rollbar(*args, &block)
+        self[:_rollbar_notifier] ||= Rollbar.notifier.scope
+        initialize_without_rollbar(*args, &block)
+      end
+
+      alias_method :initialize_without_rollbar, :initialize
+      alias_method :initialize, :initialize_with_rollbar
+    end
+  end
+end

data/lib/rollbar/plugins/validations.rb

@@ -0,0 +1,33 @@
+Rollbar.plugins.define('active_model') do
+  dependency { !configuration.disable_monkey_patch }
+  dependency { defined?(ActiveModel::Validations) }
+  dependency do
+    require 'active_record/version'
+
+    ActiveModel::VERSION::MAJOR >= 3
+  end
+
+  execute do
+    module Rollbar
+      # Module that defines methods to be used by instances using
+      # ActiveModel::Validations
+      # The name is ActiveRecordExtension in order to not break backwards
+      # compatibility, although probably it should be named
+      # Rollbar::ValidationsExtension or similar
+      module ActiveRecordExtension
+        def report_validation_errors_to_rollbar
+          errors.full_messages.each do |error|
+            Rollbar.log_info "[Rollbar] Reporting form validation error: #{error} for #{self}"
+            Rollbar.warning("Form Validation Error: #{error} for #{self}")
+          end
+        end
+      end
+    end
+  end
+
+  execute do
+    ActiveModel::Validations.module_eval do
+      include Rollbar::ActiveRecordExtension
+    end
+  end
+end

data/lib/rollbar/request_data_extractor.rb

@@ -23,20 +23,15 @@ module Rollbar
       rack_req = ::Rack::Request.new(env)
 
       sensitive_params = sensitive_params_list(env)
-      request_params = rollbar_filtered_params(sensitive_params, rollbar_request_params(env))
-      get_params = rollbar_filtered_params(sensitive_params, rollbar_get_params(rack_req))
-      post_params = rollbar_filtered_params(sensitive_params, rollbar_post_params(rack_req))
-      raw_body_params = rollbar_filtered_params(sensitive_params, mergeable_raw_body_params(rack_req))
-      cookies = rollbar_filtered_params(sensitive_params, rollbar_request_cookies(rack_req))
-      session = rollbar_filtered_params(sensitive_params, rollbar_request_session(rack_req))
-      route_params = rollbar_filtered_params(sensitive_params, rollbar_route_params(env))
-
-      url_scrubber = Rollbar::Scrubbers::URL.new(:scrub_fields => sensitive_params,
-                                                 :scrub_user => Rollbar.configuration.scrub_user,
-                                                 :scrub_password => Rollbar.configuration.scrub_password,
-                                                 :randomize_scrub_length => Rollbar.configuration.randomize_scrub_length)
-      url = url_scrubber.call(rollbar_url(env))
-
+      request_params = scrub_params(rollbar_request_params(env), sensitive_params)
+      get_params = scrub_params(rollbar_get_params(rack_req), sensitive_params)
+      post_params = scrub_params(rollbar_post_params(rack_req), sensitive_params)
+      raw_body_params = scrub_params(mergeable_raw_body_params(rack_req), sensitive_params)
+      cookies = scrub_params(rollbar_request_cookies(rack_req), sensitive_params)
+      session = scrub_params(rollbar_request_session(rack_req), sensitive_params)
+      route_params = scrub_params(rollbar_route_params(env), sensitive_params)
+
+      url = scrub_url(rollbar_url(env), sensitive_params)
       params = request_params.merge(get_params).merge(post_params).merge(raw_body_params)
 
       data = {
@@ -57,6 +52,27 @@ module Rollbar
       data
     end
 
+    def scrub_url(url, sensitive_params)
+      options = {
+        :url => url,
+        :scrub_fields => Array(Rollbar.configuration.scrub_fields) + sensitive_params,
+        :scrub_user => Rollbar.configuration.scrub_user,
+        :scrub_password => Rollbar.configuration.scrub_password,
+        :randomize_scrub_length => Rollbar.configuration.randomize_scrub_length
+      }
+
+      Rollbar::Scrubbers::URL.call(options)
+    end
+
+    def scrub_params(params, sensitive_params)
+      options = {
+        :params => params,
+        :config => Rollbar.configuration.scrub_fields,
+        :extra_fields => sensitive_params
+      }
+      Rollbar::Scrubbers::Params.call(options)
+    end
+
     private
 
     def mergeable_raw_body_params(rack_req)
@@ -180,10 +196,6 @@ module Rollbar
       {}
     end
 
-    def rollbar_filtered_params(sensitive_params, params)
-      Rollbar::Scrubbers::Params.call(params, sensitive_params)
-    end
-
     def sensitive_params_list(env)
       Array(env['action_dispatch.parameter_filter'])
     end

data/lib/rollbar/scrubbers/params.rb

@@ -15,10 +15,12 @@ module Rollbar
         new.call(*args)
       end
 
-      def call(params, extra_fields = [])
+      def call(options = {})
+        params = options[:params]
         return {} unless params
 
-        config = Rollbar.configuration.scrub_fields
+        config = options[:config]
+        extra_fields = options[:extra_fields]
 
         scrub(params, build_scrub_options(config, extra_fields))
       end

data/lib/rollbar/scrubbers/url.rb

@@ -6,34 +6,36 @@ require 'rollbar/language_support'
 module Rollbar
   module Scrubbers
     class URL
-      attr_reader :regex
-      attr_reader :scrub_user
-      attr_reader :scrub_password
-      attr_reader :randomize_scrub_length
-
-      def initialize(options = {})
-        @regex = build_regex(options[:scrub_fields])
-        @scrub_user = options[:scrub_user]
-        @scrub_password = options[:scrub_password]
-        @randomize_scrub_length = options.fetch(:randomize_scrub_length, true)
+      def self.call(*args)
+        new.call(*args)
       end
 
-      def call(url)
+      def call(options = {})
+        url = options[:url]
         return url unless Rollbar::LanguageSupport.can_scrub_url?
 
+        filter(url,
+               build_regex(options[:scrub_fields]),
+               options[:scrub_user],
+               options[:scrub_password],
+               options.fetch(:randomize_scrub_length, true))
+      rescue => e
+        Rollbar.logger.error("[Rollbar] There was an error scrubbing the url: #{e}, options: #{options.inspect}")
+        url
+      end
+
+      private
+
+      def filter(url, regex, scrub_user, scrub_password, randomize_scrub_length)
         uri = URI.parse(url)
 
-        uri.user = filter_user(uri.user)
-        uri.password = filter_password(uri.password)
-        uri.query = filter_query(uri.query)
+        uri.user = filter_user(uri.user, scrub_user, randomize_scrub_length)
+        uri.password = filter_password(uri.password, scrub_password, randomize_scrub_length)
+        uri.query = filter_query(uri.query, regex, randomize_scrub_length)
 
         uri.to_s
-      rescue
-        url
       end
 
-      private
-
       # Builds a regex to match with any of the received fields.
       # The built regex will also match array params like 'user_ids[]'.
       def build_regex(fields)
@@ -42,20 +44,20 @@ module Rollbar
         Regexp.new("^#{fields_or}$")
       end
 
-      def filter_user(user)
-        scrub_user && user ? filtered_value(user) : user
+      def filter_user(user, scrub_user, randomize_scrub_length)
+        scrub_user && user ? filtered_value(user, randomize_scrub_length) : user
       end
 
-      def filter_password(password)
-        scrub_password && password ? filtered_value(password) : password
+      def filter_password(password, scrub_password, randomize_scrub_length)
+        scrub_password && password ? filtered_value(password, randomize_scrub_length) : password
       end
 
-      def filter_query(query)
+      def filter_query(query, regex, randomize_scrub_length)
         return query unless query
 
         params = decode_www_form(query)
 
-        encoded_query = encode_www_form(filter_query_params(params))
+        encoded_query = encode_www_form(filter_query_params(params, regex, randomize_scrub_length))
 
         # We want this to rebuild array params like foo[]=1&foo[]=2
         CGI.unescape(encoded_query)
@@ -69,17 +71,17 @@ module Rollbar
         URI.encode_www_form(params)
       end
 
-      def filter_query_params(params)
+      def filter_query_params(params, regex, randomize_scrub_length)
         params.map do |key, value|
-          [key, filter_key?(key) ? filtered_value(value) : value]
+          [key, filter_key?(key, regex) ? filtered_value(value, randomize_scrub_length) : value]
         end
       end
 
-      def filter_key?(key)
+      def filter_key?(key, regex)
         !!(key =~ regex)
       end
 
-      def filtered_value(value)
+      def filtered_value(value, randomize_scrub_length)
         if randomize_scrub_length
           random_filtered_value
         else

data/lib/rollbar/util.rb

@@ -91,5 +91,15 @@ module Rollbar
 
       str.unpack("U*").slice(0, length - ellipsis.length).pack("U*") + ellipsis
     end
+
+    def self.uuid_rollbar_url(data, configuration)
+      "#{configuration.web_base}/instance/uuid?uuid=#{data[:uuid]}"
+    end
+
+    def self.enforce_valid_utf8(payload)
+      normalizer = lambda { |object| Encoding.encode(object) }
+
+      Util.iterate_and_update(payload, normalizer)
+    end
   end
 end

data/lib/rollbar/version.rb

@@ -1,3 +1,3 @@
 module Rollbar
-  VERSION = '2.10.0'
+  VERSION = '2.11.0'
 end

data/spec/controllers/home_controller_spec.rb

@@ -12,13 +12,14 @@ describe HomeController do
     Rollbar.configure do |config|
       config.access_token = test_access_token
       config.logger = logger_mock
+      config.open_timeout = 60
       config.request_timeout = 60
     end
   end
 
   context "rollbar base_data" do
     it 'should have the Rails environment' do
-      data = Rollbar.notifier.send(:build_payload, 'error', 'message', nil, nil)
+      data = Rollbar.notifier.send(:build_item, 'error', 'message', nil, nil)
       data['data'][:environment].should == ::Rails.env
     end
 
@@ -27,7 +28,7 @@ describe HomeController do
         config.environment = 'dev'
       end
 
-      data = Rollbar.notifier.send(:build_payload, 'error', 'message', nil, nil)
+      data = Rollbar.notifier.send(:build_item, 'error', 'message', nil, nil)
       data['data'][:environment].should == 'dev'
     end
 
@@ -35,7 +36,7 @@ describe HomeController do
       old_env, ::Rails.env = ::Rails.env, ''
       preconfigure_rails_notifier
 
-      data = Rollbar.notifier.send(:build_payload, 'error', 'message', nil, nil)
+      data = Rollbar.notifier.send(:build_item, 'error', 'message', nil, nil)
       data['data'][:environment].should == 'unspecified'
 
       ::Rails.env = old_env

data/spec/dummyapp/app/models/post.rb

@@ -0,0 +1,9 @@
+class Post
+  include ActiveModel::Validations
+  include ActiveModel::Validations::Callbacks
+
+  attr_accessor :title
+
+  validates_presence_of :title
+  after_validation :report_validation_errors_to_rollbar
+end

data/spec/dummyapp/app/models/user.rb

@@ -4,4 +4,6 @@ class User < ActiveRecord::Base
     attr_accessible :username, :email, :password, :password_confirmation, :remember_me
   end
 
+  validates_presence_of :email
+  after_validation :report_validation_errors_to_rollbar
 end

data/spec/dummyapp/config/initializers/rollbar.rb

@@ -1,5 +1,6 @@
 Rollbar.configure do |config|
   config.access_token = 'aaaabbbbccccddddeeeeffff00001111'
+  config.open_timeout = 60
   config.request_timeout = 60
   config.js_enabled = true
   config.js_options = {

data/spec/fixtures/plugins/dummy1.rb

@@ -0,0 +1,5 @@
+require 'rollbar/plugins'
+
+Rollbar.plugins.define(:dummy1) do
+  dependency { true }
+end

data/spec/fixtures/plugins/dummy2.rb

@@ -0,0 +1,5 @@
+require 'rollbar/plugins'
+
+Rollbar.plugins.define(:dummy2) do
+  dependency { true }
+end

data/spec/rollbar/item_spec.rb

@@ -0,0 +1,635 @@
+require 'spec_helper'
+require 'rollbar/configuration'
+require 'rollbar/item'
+require 'rollbar/lazy_store'
+
+describe Rollbar::Item do
+  let(:notifier) { double('notifier', :safely => safely_notifier) }
+  let(:safely_notifier) { double('safely_notifier') }
+  let(:logger) { double }
+  let(:configuration) do
+    c = Rollbar::Configuration.new
+    c.enabled = true
+    c.access_token = 'footoken'
+    c.root = '/foo/'
+    c.framework = 'Rails'
+    c
+  end
+  let(:level) { 'info' }
+  let(:message) { 'message' }
+  let(:exception) {}
+  let(:extra) {}
+  let(:scope) {}
+
+  let(:options) do
+    {
+      :level => level,
+      :message => message,
+      :exception => exception,
+      :extra => extra,
+      :configuration => configuration,
+      :logger => logger,
+      :scope => scope,
+      :notifier => notifier
+    }
+  end
+
+  subject { described_class.new(options) }
+
+  describe '#build' do
+    let(:payload) { subject.build }
+
+    context 'a basic payload' do
+      let(:extra) { {:key => 'value', :hash => {:inner_key => 'inner_value'}} }
+
+      it 'calls Rollbar::Util.enforce_valid_utf8' do
+        expect(Rollbar::Util).to receive(:enforce_valid_utf8).with(kind_of(Hash))
+
+        subject.build
+      end
+
+      it 'should have the correct root-level keys' do
+        payload.keys.should match_array(['access_token', 'data'])
+      end
+
+      it 'should have the correct data keys' do
+        payload['data'].keys.should include(:timestamp, :environment, :level, :language, :framework, :server,
+                                            :notifier, :body)
+      end
+
+      it 'should have the correct notifier name and version' do
+        payload['data'][:notifier][:name].should == 'rollbar-gem'
+        payload['data'][:notifier][:version].should == Rollbar::VERSION
+      end
+
+      it 'should have the correct language and framework' do
+        payload['data'][:language].should == 'ruby'
+        payload['data'][:framework].should == configuration.framework
+        payload['data'][:framework].should match(/^Rails/)
+      end
+
+      it 'should have the correct server keys' do
+        payload['data'][:server].keys.should match_array([:host, :root, :pid])
+      end
+
+      it 'should have the correct level and message body' do
+        payload['data'][:level].should == 'info'
+        payload['data'][:body][:message][:body].should == 'message'
+      end
+    end
+
+    it 'should merge in a new key from payload_options' do
+      configuration.payload_options = { :some_new_key => 'some new value' }
+
+      payload['data'][:some_new_key].should == 'some new value'
+    end
+
+    it 'should overwrite existing keys from payload_options' do
+      payload_options = {
+        :notifier => 'bad notifier',
+        :server => { :host => 'new host', :new_server_key => 'value' }
+      }
+      configuration.payload_options = payload_options
+
+      payload['data'][:notifier].should == 'bad notifier'
+      payload['data'][:server][:host].should == 'new host'
+      payload['data'][:server][:root].should_not be_nil
+      payload['data'][:server][:new_server_key].should == 'value'
+    end
+
+    it 'should have default environment "unspecified"' do
+      configuration.environment = nil
+
+      payload['data'][:environment].should == 'unspecified'
+    end
+
+    it 'should have an overridden environment' do
+      configuration.environment = 'overridden'
+
+      payload['data'][:environment].should == 'overridden'
+    end
+
+    it 'should not have custom data under default configuration' do
+      payload['data'][:body][:message][:extra].should be_nil
+    end
+
+    it 'should have custom message data when custom_data_method is configured' do
+      configuration.custom_data_method = lambda { {:a => 1, :b => [2, 3, 4]} }
+
+      payload['data'][:body][:message][:extra].should_not be_nil
+      payload['data'][:body][:message][:extra][:a].should == 1
+      payload['data'][:body][:message][:extra][:b][2].should == 4
+    end
+
+    context do
+      let(:extra) do
+        { :c => {:e => 'g' }, :f => 'f' }
+      end
+
+      it 'should merge extra data into custom message data' do
+        custom_method = lambda do
+          { :a => 1,
+            :b => [2, 3, 4],
+            :c => { :d => 'd', :e => 'e' },
+            :f => ['1', '2']
+          }
+        end
+        configuration.custom_data_method = custom_method
+
+        payload['data'][:body][:message][:extra].should_not be_nil
+        payload['data'][:body][:message][:extra][:a].should == 1
+        payload['data'][:body][:message][:extra][:b][2].should == 4
+        payload['data'][:body][:message][:extra][:c][:d].should == 'd'
+        payload['data'][:body][:message][:extra][:c][:e].should == 'g'
+        payload['data'][:body][:message][:extra][:f].should == 'f'
+      end
+    end
+
+    context 'with custom_data_method crashing' do
+      next unless defined?(SecureRandom) && SecureRandom.respond_to?(:uuid)
+
+      let(:crashing_exception) { StandardError.new }
+      let(:custom_method) { proc { raise crashing_exception } }
+      let(:extra) { { :foo => :bar } }
+      let(:custom_data_report) do
+        { :_error_in_custom_data_method => SecureRandom.uuid }
+      end
+      let(:expected_extra) { extra.merge(custom_data_report) }
+
+      before do
+        configuration.custom_data_method = custom_method
+      end
+
+      it 'doesnt crash the report' do
+        expect(subject).to receive(:report_custom_data_error).once.and_return(custom_data_report)
+
+        expect(payload['data'][:body][:message][:extra]).to be_eql(expected_extra)
+      end
+
+      context 'and for some reason the safely.error returns a String' do
+        it 'returns an empty Hash' do
+          allow(safely_notifier).to receive(:error).and_return('ignored')
+
+          expect(payload['data'][:body][:message][:extra]).to be_eql(extra)
+        end
+      end
+    end
+
+    it 'should include project_gem_paths' do
+      gems = Gem::Specification.map(&:name)
+      project_gems = ['rails']
+      project_gems << 'rspec' if gems.include?('rspec')
+      project_gems << 'rspec-core' if gems.include?('rspec-core')
+
+      configuration.project_gems = project_gems
+
+      expect(payload['data'][:project_package_paths].count).to eq(project_gems.size)
+    end
+
+    it 'should include a code_version' do
+      configuration.code_version = 'abcdef'
+
+      payload['data'][:code_version].should == 'abcdef'
+    end
+
+    it 'should have the right hostname' do
+      payload['data'][:server][:host].should == Socket.gethostname
+    end
+
+    it 'should have root and branch set when configured' do
+      configuration.root = '/path/to/root'
+      configuration.branch = 'master'
+
+      payload['data'][:server][:root].should == '/path/to/root'
+      payload['data'][:server][:branch].should == 'master'
+    end
+
+    context 'build_payload_body' do
+      let(:exception) do
+        begin
+          foo = bar
+        rescue => e
+          e
+        end
+      end
+
+      context 'with no exception' do
+        let(:exception) { nil }
+
+        it 'should build a message body when no exception is passed in' do
+          payload['data'][:body][:message][:body].should == 'message'
+          payload['data'][:body][:message][:extra].should be_nil
+          payload['data'][:body][:trace].should be_nil
+        end
+
+        context 'and extra data' do
+          let(:extra) do
+            {:a => 'b'}
+          end
+
+          it 'should build a message body when no exception and extra data is passed in' do
+            payload['data'][:body][:message][:body].should == 'message'
+            payload['data'][:body][:message][:extra].should == {:a => 'b'}
+            payload['data'][:body][:trace].should be_nil
+          end
+        end
+      end
+
+      it 'should build an exception body when one is passed in' do
+        body = payload['data'][:body]
+        body[:message].should be_nil
+
+        trace = body[:trace]
+        trace.should_not be_nil
+        trace[:extra].should be_nil
+
+        trace[:exception][:class].should_not be_nil
+        trace[:exception][:message].should_not be_nil
+      end
+
+      context 'with extra data' do
+        let(:extra) do
+          {:a => 'b'}
+        end
+
+        it 'should build an exception body when one is passed in along with extra data' do
+          body = payload['data'][:body]
+          body[:message].should be_nil
+
+          trace = body[:trace]
+          trace.should_not be_nil
+
+          trace[:exception][:class].should_not be_nil
+          trace[:exception][:message].should_not be_nil
+          trace[:extra].should == {:a => 'b'}
+        end
+      end
+    end
+
+    context 'build_payload_body_exception' do
+      let(:exception) do
+        begin
+          foo = bar
+        rescue => e
+          e
+        end
+      end
+
+      it 'should build valid exception data' do
+        body = payload['data'][:body]
+        body[:message].should be_nil
+
+        trace = body[:trace]
+
+        frames = trace[:frames]
+        frames.should be_a_kind_of(Array)
+        frames.each do |frame|
+          frame[:filename].should be_a_kind_of(String)
+          frame[:lineno].should be_a_kind_of(Fixnum)
+          if frame[:method]
+            frame[:method].should be_a_kind_of(String)
+          end
+        end
+
+        # should be NameError, but can be NoMethodError sometimes on rubinius 1.8
+        # http://yehudakatz.com/2010/01/02/the-craziest-fing-bug-ive-ever-seen/
+        trace[:exception][:class].should match(/^(NameError|NoMethodError)$/)
+        trace[:exception][:message].should match(/^(undefined local variable or method `bar'|undefined method `bar' on an instance of)/)
+      end
+
+      context 'with description message' do
+        let(:message) { 'exception description' }
+
+        it 'should build exception data with a description' do
+          body = payload['data'][:body]
+
+          trace = body[:trace]
+
+          trace[:exception][:message].should match(/^(undefined local variable or method `bar'|undefined method `bar' on an instance of)/)
+          trace[:exception][:description].should == 'exception description'
+        end
+
+        context 'and extra data' do
+          let(:extra) do
+            {:key => 'value', :hash => {:inner_key => 'inner_value'}}
+          end
+
+          it 'should build exception data with a description and extra data' do
+            body = payload['data'][:body]
+            trace = body[:trace]
+
+            trace[:exception][:message].should match(/^(undefined local variable or method `bar'|undefined method `bar' on an instance of)/)
+            trace[:exception][:description].should == 'exception description'
+            trace[:extra][:key].should == 'value'
+            trace[:extra][:hash].should == {:inner_key => 'inner_value'}
+          end
+        end
+      end
+
+      context 'with extra data' do
+        let(:extra) do
+          {:key => 'value', :hash => {:inner_key => 'inner_value'}}
+        end
+        it 'should build exception data with a extra data' do
+          body = payload['data'][:body]
+          trace = body[:trace]
+
+          trace[:exception][:message].should match(/^(undefined local variable or method `bar'|undefined method `bar' on an instance of)/)
+          trace[:extra][:key].should == 'value'
+          trace[:extra][:hash].should == {:inner_key => 'inner_value'}
+        end
+      end
+
+      context 'with nested exceptions' do
+        let(:crashing_code) do
+          proc do
+            begin
+              begin
+                fail CauseException.new('the cause')
+              rescue
+                fail StandardError.new('the error')
+              end
+            rescue => e
+              e
+            end
+          end
+        end
+
+        let(:exception) { crashing_code.call }
+        let(:message) { 'message' }
+        let(:extra) { {} }
+
+        context 'using ruby >= 2.1' do
+          next unless Exception.instance_methods.include?(:cause)
+
+          it 'sends the two exceptions in the trace_chain attribute' do
+            body = payload['data'][:body]
+
+            body[:trace].should be_nil
+            body[:trace_chain].should be_kind_of(Array)
+
+            chain = body[:trace_chain]
+            chain[0][:exception][:class].should match(/StandardError/)
+            chain[0][:exception][:message].should match(/the error/)
+
+            chain[1][:exception][:class].should match(/CauseException/)
+            chain[1][:exception][:message].should match(/the cause/)
+          end
+
+          context 'when cause is not an Exception' do
+            let(:exception) { Exception.new('custom cause') }
+
+            it 'ignores the cause when it is not an Exception' do
+              allow(exception).to receive(:cause) { "Foo" }
+
+              payload['data'][:body][:trace].should_not be_nil
+            end
+          end
+
+          context 'with cyclic nested exceptions' do
+            let(:exception1) { Exception.new('exception1') }
+            let(:exception2) { Exception.new('exception2') }
+            let(:exception) { exception1 }
+
+            before do
+              allow(exception1).to receive(:cause).and_return(exception2)
+              allow(exception2).to receive(:cause).and_return(exception1)
+            end
+
+            it 'doesnt loop for ever' do
+              chain = payload['data'][:body][:trace_chain]
+
+              expect(chain[0][:exception][:message]).to be_eql('exception1')
+              expect(chain[1][:exception][:message]).to be_eql('exception2')
+            end
+          end
+        end
+
+        context 'using ruby <= 2.1' do
+          next if Exception.instance_methods.include?(:cause)
+
+          it 'sends only the last exception in the trace attribute' do
+            body = payload['data'][:body]
+
+            body[:trace].should be_kind_of(Hash)
+            body[:trace_chain].should be_nil
+
+            body[:trace][:exception][:class].should match(/StandardError/)
+            body[:trace][:exception][:message].should match(/the error/)
+          end
+        end
+      end
+    end
+
+    context 'build_payload_body_message' do
+      it 'should build a message' do
+        payload['data'][:body][:message][:body].should == 'message'
+        payload['data'][:body][:trace].should be_nil
+      end
+
+      context 'with extra data' do
+        let(:extra) do
+          {:key => 'value', :hash => {:inner_key => 'inner_value'}}
+        end
+
+        it 'should build a message with extra data' do
+          payload['data'][:body][:message][:body].should == 'message'
+          payload['data'][:body][:message][:extra][:key].should == 'value'
+          payload['data'][:body][:message][:extra][:hash].should == {:inner_key => 'inner_value'}
+        end
+      end
+
+      context 'with empty message and extra data' do
+        let(:message) { nil }
+        let(:extra) do
+          {:key => 'value', :hash => {:inner_key => 'inner_value'}}
+        end
+
+        it 'should build an empty message with extra data' do
+          payload['data'][:body][:message][:body].should == 'Empty message'
+          payload['data'][:body][:message][:extra][:key].should == 'value'
+          payload['data'][:body][:message][:extra][:hash].should == {:inner_key => 'inner_value'}
+        end
+      end
+    end
+
+    context 'with transform handlers in configuration' do
+      let(:scope) { Rollbar::LazyStore.new({ :bar => :foo }) }
+      let(:message) { 'message' }
+      let(:exception) { Exception.new }
+      let(:extra) { { :foo => :bar } }
+      let(:level) { 'error' }
+
+      context 'without mutation in payload' do
+        let(:handler) do
+          proc do |options|
+
+          end
+        end
+
+        before do
+          configuration.transform = handler
+        end
+
+        it 'calls the handler with the correct options' do
+          options = {
+            :level => subject.level,
+            :scope => subject.scope,
+            :exception => subject.exception,
+            :message => subject.message,
+            :extra => subject.extra,
+            :payload => kind_of(Hash)
+          }
+
+          expect(handler).to receive(:call).with(options).and_call_original
+
+          subject.build
+        end
+      end
+
+      context 'with mutation in payload' do
+        let(:new_payload) do
+          {
+            'access_token' => configuration.access_token,
+            'data' => {
+            }
+          }
+        end
+        let(:handler) do
+          proc do |options|
+            payload = options[:payload]
+
+            payload.replace(new_payload)
+          end
+        end
+
+        before do
+          configuration.transform = handler
+        end
+
+        it 'calls the handler with the correct options' do
+          options = {
+            :level => level,
+            :scope => Rollbar::LazyStore.new(scope),
+            :exception => exception,
+            :message => message,
+            :extra => extra,
+            :payload => kind_of(Hash)
+          }
+          expect(handler).to receive(:call).with(options).and_call_original
+          expect(payload).to be_eql(new_payload)
+        end
+      end
+
+      context 'with two handlers' do
+        let(:handler1) { proc { |options|} }
+        let(:handler2) { proc { |options|} }
+
+        before do
+          configuration.transform << handler1
+          configuration.transform << handler2
+        end
+
+        context 'and the first one fails' do
+          let(:exception) { StandardError.new('foo') }
+          let(:handler1) do
+            proc { |options|  raise exception }
+          end
+
+          it 'doesnt call the second handler and logs the error' do
+            expect(handler2).not_to receive(:call)
+            expect(logger).to receive(:error).with("[Rollbar] Error calling the `transform` hook: #{exception}")
+
+            subject.build
+          end
+        end
+      end
+    end
+
+    describe '#custom_data' do
+      before do
+        configuration.custom_data_method = proc { raise 'this-will-raise' }
+
+        expect(safely_notifier).to receive(:error).and_return(report_data)
+      end
+
+      context 'with uuid in reported data' do
+        next unless defined?(SecureRandom) and SecureRandom.respond_to?(:uuid)
+
+        let(:report_data) { { :uuid => SecureRandom.uuid } }
+        let(:expected_url) { "https://rollbar.com/instance/uuid?uuid=#{report_data[:uuid]}" }
+
+        it 'returns the uuid in :_error_in_custom_data_method' do
+          expect(payload['data'][:body][:message][:extra]).to be_eql(:_error_in_custom_data_method => expected_url)
+        end
+      end
+
+      context 'without uuid in reported data' do
+        let(:report_data) { { :some => 'other-data' } }
+
+        it 'returns empty data' do
+          expect(payload['data'][:body][:message][:extra]).to be_eql({})
+        end
+      end
+    end
+
+    context 'server_data' do
+      it 'should have the right hostname' do
+        payload['data'][:server][:host] == Socket.gethostname
+      end
+
+      it 'should have root and branch set when configured' do
+        configuration.root = '/path/to/root'
+        configuration.branch = 'master'
+
+        payload['data'][:server][:root].should == '/path/to/root'
+        payload['data'][:server][:branch].should == 'master'
+      end
+    end
+
+    context 'with ignored person ids' do
+      let(:ignored_ids) { [1,2,4] }
+      let(:person_data) do
+        { :person => {
+            :id => 2,
+            :username => 'foo'
+          }
+        }
+      end
+      let(:scope) { Rollbar::LazyStore.new(person_data) }
+
+      before do
+        configuration.person_id_method = :id
+        configuration.ignored_person_ids = ignored_ids
+      end
+
+      it 'sets ignored property to true' do
+        subject.build
+
+        expect(subject).to be_ignored
+      end
+    end
+
+  end # end #build
+
+  describe '#dump' do
+    context 'with Redis instance in payload and ActiveSupport is enabled' do
+      let(:redis) { ::Redis.new }
+      let(:payload) do
+        {
+          :key => {
+            :value => redis
+          }
+        }
+      end
+      let(:item) { Rollbar::Item.build_with(payload) }
+
+      it 'dumps to JSON correctly' do
+        redis.set('foo', 'bar')
+        json = item.dump
+
+        expect(json).to be_kind_of(String)
+      end
+    end
+  end
+end