rollbar 2.12.0 → 2.13.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c81062a0a25993cc7d6e1cb8a16d6f2f2b2faf43
-  data.tar.gz: ddfba1b5a84dafd6d2b2113ae383a1a1255dd1b7
+  metadata.gz: d7a60c8f3a1929550de7236c1f2cad3f06d686ef
+  data.tar.gz: 7c91ff957d85efa7387384948174d1ea6f745b00
 SHA512:
-  metadata.gz: 498f4e0b6509703b0c2c8044f669bf9aa60417ff198376abfbb02ac5d8e4953c0cc470d97e4f68212b38368e1d62e5bcb61783d80a078fcc7dc5735eb7408ac4
-  data.tar.gz: 23fa88ce1a8422d70cc6f409439a32a703321435b2a43d7c6f2eb30ecb0ba60510d1b3e2fa0a79ff493eab9be053ac8b007767c6df8d4fd741ae0d6acd3042bf
+  metadata.gz: a53c437380edf552740dec8ece8c8bf90f774b5c1ba420ac8526f8a11eaf8bd502ec6798f70da4ce056cbadae215ebef4629cd75e81742164cc78838fc89a0ba
+  data.tar.gz: f5bda5da6010fa1a5d6d4d1571c5973e78d42fba2523731be1f5c38295cf808c7f2e9bfdb9035da143963fdb65dc8c586b739e91b4200a2a70f4f7fbafc5eea9

data/CHANGELOG.md

@@ -1,5 +1,32 @@
 # Change Log
 
+## 2.13.0
+
+Features:
+- Allow to override config. See [#519](https://github.com/rollbar/rollbar-gem/pull/519).
+- Send code and context frame data. See [#523](https://github.com/rollbar/rollbar-gem/pull/523).
+- Send GET, POST and raw body in their correct place. See [#522](https://github.com/rollbar/rollbar-gem/pull/522).
+- Increase max payload from 128kb to 512kb. See [#521](https://github.com/rollbar/rollbar-gem/pull/521).
+- Add resque-rollbar functionality to the gem. See [#516](https://github.com/rollbar/rollbar-gem/pull/516).
+- Send custom.orig_host and custom.orig_uuid on too large payloads. See [#518](https://github.com/rollbar/rollbar-gem/pull/518).
+- Add Content-Length and Content-Type headers to the reports. See [#513](https://github.com/rollbar/rollbar-gem/pull/513).
+
+Bug fixes:
+- SecureHeaders fixes. See [#478](https://github.com/rollbar/rollbar-gem/pull/478).
+- Include validations plugin in activerecord base. See [#503](https://github.com/rollbar/rollbar-gem/pull/503).
+- Require tempfile and use ::Tempfile. See [#514](https://github.com/rollbar/rollbar-gem/pull/514).
+- Extract correct client IP from X-Forwarded-For header. See [#515](https://github.com/rollbar/rollbar-gem/pull/515).
+- Delayed job fix on job serialization. See [#512](https://github.com/rollbar/rollbar-gem/pull/512).
+
+Others:
+- Fix tests on rails40 and ruby 1.8.7. See [#485](https://github.com/rollbar/rollbar-gem/pull/485).
+- Move log methods to public section. See [#498](https://github.com/rollbar/rollbar-gem/pull/498).
+- Change rails50.gemfile to use Rails 5.0.0. See [#495](https://github.com/rollbar/rollbar-gem/pull/495).
+- Update CHANGELOG.md to fix incorrect links. See [#502](https://github.com/rollbar/rollbar-gem/pull/502).
+- Improve Rake support to avoid conflicts with other services. See [#517](https://github.com/rollbar/rollbar-gem/pull/517).
+- Make Codeclimate happier with Rollbar::Middlware::Js. See [#520](https://github.com/rollbar/rollbar-gem/pull/520).
+
+
 ## 2.12.0
 
 Features:
@@ -13,7 +40,7 @@ Others:
 
 ## 2.11.5
 
-Bugfixes:
+Bugf ixes:
 
 - Use require_dependency for rake and sidekiq plugins. See [#485](https://github.com/rollbar/rollbar-gem/pull/485).
 - Add immediate ActiveModel::Validations monkey patch. See [#484](https://github.com/rollbar/rollbar-gem/pull/484).
@@ -53,7 +80,7 @@ Bug fixes:
 
 New features:
 
-- Rollbar.js support wit SecureHeaders 2.0. See [#448](https://github.com/rollbar/rollbar-gem/pull/448).
+- Rollbar.js support with SecureHeaders 2.0. See [#448](https://github.com/rollbar/rollbar-gem/pull/448).
 - Inject extensions in ActiveModel::Validations instead of ActiveRecord::Base. See [#445](https://github.com/rollbar/rollbar-gem/pull/445).
 
 Bug fixes:
@@ -64,7 +91,7 @@ Bug fixes:
 
 Refactors and others:
 
-- Refactor Item payload building. See [#452](https://github.com/rollbar/rollbar-gem/pull/454).
+- Refactor Item payload building. See [#452](https://github.com/rollbar/rollbar-gem/pull/452).
 - Mock the requests to Rollbar API. See [#450](https://github.com/rollbar/rollbar-gem/pull/450).
 - Add plugins architecture. See [#438](https://github.com/rollbar/rollbar-gem/pull/438).
 - Add TOC for README.md. See [#444](https://github.com/rollbar/rollbar-gem/pull/444).
@@ -199,8 +226,8 @@ Features
 
 Bug fixes:
 
-- Use ACCEPT header to check json requests. See [#328](https://github.com/rollbar/rollbar-gem/pull/333)
-- Fix URL scrubbing when using a malformed URL. See [#328](https://github.com/rollbar/rollbar-gem/pull/332)
+- Use ACCEPT header to check json requests. See [#333](https://github.com/rollbar/rollbar-gem/pull/333)
+- Fix URL scrubbing when using a malformed URL. See [#332](https://github.com/rollbar/rollbar-gem/pull/332)
 
 ## 2.5.1
 
@@ -237,7 +264,7 @@ Documentation:
 
 Bug fixes:
 
-- Remove better errors hook. This was causing to report twice the errors. See [#313](https://github.com/rollbar/rollbar-gem/pull/300)
+- Remove better errors hook. This was causing to report twice the errors. See [#313](https://github.com/rollbar/rollbar-gem/pull/313)
 
 
 ## 2.3.0

data/README.md

@@ -1,10 +1,4 @@
----
-layout: page
-sidebar: rollbar_sidebar
-permalink: /notifiers/rollbar-gem/
-toc: false
----
-# Rollbar [![Build Status](https://api.travis-ci.org/rollbar/rollbar-gem.svg?branch=v2.12.0)](https://travis-ci.org/rollbar/rollbar-gem/branches)
+# Rollbar [![Build Status](https://api.travis-ci.org/rollbar/rollbar-gem.svg?branch=v2.13.0)](https://travis-ci.org/rollbar/rollbar-gem/branches)
 
 <!-- RemoveNext -->
 [Rollbar](https://rollbar.com) is an error tracking service for Ruby and other languages. The Rollbar service will alert you of problems with your code and help you understand them in a ways never possible before. We love it and we hope you will too.
@@ -36,6 +30,8 @@ This is the Ruby library for Rollbar. It will instrument many kinds of Ruby appl
 - [Before process hook](#before-process-hook)
 - [Transform hook](#transform-hook)
 - [The Scope](#the-scope)
+- [Override configuration](#override-configuration)
+- [Code and context](#code-and-context)
 - [Silencing exceptions at runtime](#silencing-exceptions-at-runtime)
 - [Sending backtrace without rescued exceptions](#sending-backtrace-without-rescued-exceptions)
 - [ActiveJob integration](#activejob-integration)
@@ -613,6 +609,49 @@ your_handler = proc do |options|
 end
 ```
 
+## Override configuration
+
+There are some cases where you would need to change the Rollbar configuration for a specific block of code so a new configuration is used on the reported errors in that block. You can use `Rollbar.with_config` to do this. It receives a `Hash` object with the configuration overrides you want to use for the given block. The configuration options to use can be read at [Configuration](https://rollbar.com/docs/notifier/rollbar-gem/configuration/). So the `Hash` passed to `with_config` can be like `{environment: 'specific-environment'}`. Example:
+
+```ruby
+Rollbar.with_config(use_async: false) do
+  begin
+    # do work that may crash
+  rescue => e
+    Rollbar.error(e)
+  end
+end
+```
+
+This method looks similar to `Rollbar.scoped` and internally `Rollbar.with_config` uses it. Now `Rollbar.scoped` can receive a second argument with the config overrides for the given block of code. So if you need to set a new payload scope and new config for a code block, you can:
+
+```ruby
+scope = {context: 'foo'}
+new_config = {framework: 'Sinatra'}
+
+Rollbar.scoped(scope, new_config) do
+  begin
+    # do work that may crash
+  rescue => e
+    Rollbar.error(e)
+  end
+end
+```
+
+In the example from above we are defining a new payload scope and overriding the `framework` configuration for the reported errors inside the given block.
+
+## Code and context
+
+By default we send the following values for each backtrace frame: `filename`, `lineno` and `method`. You can configure Rollbar to additionally send `code` (the actual line of code) and `context` (lines before and after) for each frame.
+
+Since the backtrace can be very long, you can configure to send this data for all the frames or only your in-project frames. There are three levels: `:none` (default), `:app` (only your project files) and `:all`. Example:
+
+```ruby
+Rollbar.configure do |config|
+   config.send_extra_frame_data = :app
+end
+```
+
 ## Silencing exceptions at runtime
 
 If you just want to disable exception reporting for a single block, use ```Rollbar.silenced```:
@@ -937,7 +976,18 @@ If you're using [Goalie](https://github.com/obvio171/goalie) for custom error pa
 
 ## Resque
 
-Check out [resque-rollbar](https://github.com/dimko/resque-rollbar) for using Rollbar as a failure backend for Resque.
+From a time ago, Resque errors reporting was supported by the gem [resque-rollbar](https://github.com/dimko/resque-rollbar). Now that functionality is built-in in the own gem. All you need to do is use `Resque::Failure::Rollbar` as the failure backend for Resque.
+
+In your resque configuration add next lines:
+
+```ruby
+require 'resque/failure/multiple'
+require 'resque/failure/redis'
+require 'rollbar'
+
+Resque::Failure::Multiple.classes = [ Resque::Failure::Redis, Resque::Failure::Rollbar ]
+Resque::Failure.backend = Resque::Failure::Multiple
+```
 
 ## SSL
 

data/docs/configuration.md

@@ -102,6 +102,18 @@ Rollbar notifier.
 
 The number of job failures before reporting the failure to Rollbar.
 
+### enabled
+
+**Default** `true`
+
+Set to false to turn Rollbar off and stop reporting errors.
+
+### environment
+
+**Default** unspecified
+
+The environment that your code is running in.
+
 ### failover_handlers
 
 An array of backup handlers if the async handlers fails. Each should respond to

data/gemfiles/rails30.gemfile

@@ -41,5 +41,6 @@ if Gem::Version.new(RUBY_VERSION) < Gem::Version.new('2.0')
 end
 
 gem 'webmock', :require => false
+gem 'resque'
 
 gemspec :path => '../'

data/gemfiles/rails31.gemfile

@@ -39,5 +39,6 @@ if Gem::Version.new(RUBY_VERSION) < Gem::Version.new('2.0')
 end
 
 gem 'webmock', :require => false
+gem 'resque'
 
 gemspec :path => "../"

data/gemfiles/rails32.gemfile

@@ -41,5 +41,6 @@ if Gem::Version.new(RUBY_VERSION) < Gem::Version.new('2.0')
 end
 
 gem 'webmock', :require => false
+gem 'resque'
 
 gemspec :path => "../"

data/gemfiles/rails40.gemfile

@@ -23,8 +23,10 @@ gem 'sidekiq', '>= 2.13.0' if RUBY_VERSION != '1.8.7'
 
 if RUBY_VERSION.start_with?('1.9')
   gem 'sucker_punch', '~> 1.0'
+  gem 'json', '~> 1.8'
 elsif RUBY_VERSION.start_with?('2')
   gem 'sucker_punch', '~> 2.0'
+  gem 'json', '~> 2.0'
 end
 
 gem 'sinatra'
@@ -41,5 +43,6 @@ if Gem::Version.new(RUBY_VERSION) < Gem::Version.new('2.0')
 end
 
 gem 'webmock', :require => false
+gem 'resque'
 
 gemspec :path => "../"

data/gemfiles/rails41.gemfile

@@ -39,5 +39,6 @@ if Gem::Version.new(RUBY_VERSION) < Gem::Version.new('2.0')
 end
 
 gem 'webmock', :require => false
+gem 'resque'
 
 gemspec :path => "../"

data/gemfiles/rails42.gemfile

@@ -16,7 +16,6 @@ gem "rails", "4.2.3"
 gem 'rspec-rails', '~> 3.4'
 gem 'rake'
 
-gem 'oj', '~> 2.12.14' unless is_jruby
 gem 'sidekiq', '>= 2.13.0' if RUBY_VERSION != '1.8.7'
 
 if RUBY_VERSION.start_with?('1.9')
@@ -25,6 +24,12 @@ elsif RUBY_VERSION.start_with?('2')
   gem 'sucker_punch', '~> 2.0'
 end
 
+if RUBY_VERSION.start_with?('2.4')
+  gem 'oj', '~> 2.16.0' unless is_jruby
+else
+  gem 'oj', '~> 2.12.14' unless is_jruby
+end
+
 gem 'sinatra'
 gem 'resque'
 gem 'delayed_job', :require => false
@@ -39,5 +44,6 @@ if Gem::Version.new(RUBY_VERSION) < Gem::Version.new('2.0')
 end
 
 gem 'webmock', :require => false
+gem 'resque'
 
 gemspec :path => "../"

data/gemfiles/rails50.gemfile

@@ -12,7 +12,7 @@ gem 'rubysl', '~> 2.0', :platform => :rbx
 gem 'racc', :platform => :rbx
 gem 'minitest', :platform => :rbx
 gem 'rubinius-developer_tools', :platform => :rbx
-gem 'rails', '~> 5.0.0.beta1'
+gem 'rails', '~> 5.0.0'
 
 gem 'rspec-core', '~> 3.5.0.beta3'
 gem 'rspec-rails', '~> 3.5.0.beta3'
@@ -45,5 +45,6 @@ if Gem::Version.new(RUBY_VERSION) < Gem::Version.new('2.0')
 end
 
 gem 'webmock', :require => false
+gem 'resque'
 
 gemspec :path => '../'

data/gemfiles/ruby_1_8_and_1_9_2.gemfile

@@ -33,11 +33,13 @@ gem 'resque'
 gem 'delayed_job', :require => false
 gem 'redis'
 gem 'database_cleaner', '~> 1.0.0'
-gem 'genspec', '>= 0.2.8'
+gem 'genspec', '= 0.2.8'
 gem 'girl_friday', '>= 0.11.1'
 
 if Gem::Version.new(RUBY_VERSION) < Gem::Version.new('2.0')
   gem 'mime-types', '< 3.0'
 end
 
+gem 'resque'
+
 gemspec :path => '../'

data/lib/rollbar.rb

@@ -12,633 +12,19 @@ end
 
 require 'rollbar/version'
 require 'rollbar/plugins'
-require 'rollbar/json'
-require 'rollbar/js'
 require 'rollbar/configuration'
-require 'rollbar/item'
-require 'rollbar/encoding'
 require 'rollbar/logger_proxy'
-require 'rollbar/exception_reporter'
-require 'rollbar/util'
-require 'rollbar/delay/girl_friday' if defined?(GirlFriday)
-require 'rollbar/delay/thread'
-require 'rollbar/truncation'
 require 'rollbar/exceptions'
 require 'rollbar/lazy_store'
-require 'rollbar/language_support'
+require 'rollbar/notifier'
 
+# The Rollbar module. It stores a Rollbar::Notifier per thread and
+# provides some module methods in order to use the current thread notifier.
 module Rollbar
   PUBLIC_NOTIFIER_METHODS = %w(debug info warn warning error critical log logger
-                               process_item process_from_async_handler scope send_failsafe log_info log_debug
-                               log_warning log_error silenced)
-
-  class Notifier
-    attr_accessor :configuration
-    attr_accessor :last_report
-    attr_reader :scope_object
-
-    @file_semaphore = Mutex.new
-
-    def initialize(parent_notifier = nil, payload_options = nil, scope = nil)
-      if parent_notifier
-        @configuration = parent_notifier.configuration.clone
-        @scope_object = parent_notifier.scope_object.clone
-
-        Rollbar::Util.deep_merge(@configuration.payload_options, payload_options) if payload_options
-        Rollbar::Util.deep_merge(@scope_object, scope) if scope
-      else
-        @configuration = ::Rollbar::Configuration.new
-        @scope_object = ::Rollbar::LazyStore.new(scope)
-      end
-    end
-
-    # Similar to configure below, but used only internally within the gem
-    # to configure it without initializing any of the third party hooks
-    def preconfigure
-      yield(configuration)
-    end
-
-    # Configures the notifier instance
-    def configure
-      configuration.enabled = true if configuration.enabled.nil?
-
-      yield(configuration)
-    end
-
-    def scope(options = {})
-      self.class.new(self, nil, options)
-    end
-
-    def scope!(options = {})
-      Rollbar::Util.deep_merge(scope_object, options)
-
-      self
-    end
-
-    # Returns a new notifier with same configuration options
-    # but it sets Configuration#safely to true.
-    # We are using this flag to avoid having inifite loops
-    # when evaluating some custom user methods.
-    def safely
-      new_notifier = scope
-      new_notifier.configuration.safely = true
-
-      new_notifier
-    end
-
-    # Turns off reporting for the given block.
-    #
-    # @example
-    #   Rollbar.silenced { raise }
-    #
-    # @yield Block which exceptions won't be reported.
-    def silenced
-      yield
-    rescue => e
-      e.instance_variable_set(:@_rollbar_do_not_report, true)
-      raise
-    end
-
-    # Sends a report to Rollbar.
-    #
-    # Accepts any number of arguments. The last String argument will become
-    # the message or description of the report. The last Exception argument
-    # will become the associated exception for the report. The last hash
-    # argument will be used as the extra data for the report.
-    #
-    # @example
-    #   begin
-    #     foo = bar
-    #   rescue => e
-    #     Rollbar.log(e)
-    #   end
-    #
-    # @example
-    #   Rollbar.log('This is a simple log message')
-    #
-    # @example
-    #   Rollbar.log(e, 'This is a description of the exception')
-    #
-    def log(level, *args)
-      return 'disabled' unless configuration.enabled
-
-      message, exception, extra = extract_arguments(args)
-      use_exception_level_filters = extra && extra.delete(:use_exception_level_filters) == true
-
-      return 'ignored' if ignored?(exception, use_exception_level_filters)
-
-      begin
-        call_before_process(:level => level,
-                            :exception => exception,
-                            :message => message,
-                            :extra => extra)
-      rescue Rollbar::Ignore
-        return 'ignored'
-      end
-
-      level = lookup_exception_level(level, exception,
-                                     use_exception_level_filters)
-
-      begin
-        report(level, message, exception, extra)
-      rescue Exception => e
-        report_internal_error(e)
-
-        'error'
-      end
-    end
-
-    # See log() above
-    def debug(*args)
-      log('debug', *args)
-    end
-
-    # See log() above
-    def info(*args)
-      log('info', *args)
-    end
-
-    # See log() above
-    def warn(*args)
-      log('warning', *args)
-    end
-
-    # See log() above
-    def warning(*args)
-      log('warning', *args)
-    end
-
-    # See log() above
-    def error(*args)
-      log('error', *args)
-    end
-
-    # See log() above
-    def critical(*args)
-      log('critical', *args)
-    end
-
-    def process_item(item)
-      if configuration.write_to_file
-        if configuration.use_async
-          @file_semaphore.synchronize {
-            write_item(item)
-          }
-        else
-          write_item(item)
-        end
-      else
-        send_item(item)
-      end
-    rescue => e
-      log_error("[Rollbar] Error processing the item: #{e.class}, #{e.message}. Item: #{item.payload.inspect}")
-      raise e
-    end
-
-    # We will reraise exceptions in this method so async queues
-    # can retry the job or, in general, handle an error report some way.
-    #
-    # At same time that exception is silenced so we don't generate
-    # infinite reports. This example is what we want to avoid:
-    #
-    # 1. New exception in a the project is raised
-    # 2. That report enqueued to Sidekiq queue.
-    # 3. The Sidekiq job tries to send the report to our API
-    # 4. The report fails, for example cause a network failure,
-    #    and a exception is raised
-    # 5. We report an internal error for that exception
-    # 6. We reraise the exception so Sidekiq job fails and
-    #    Sidekiq can retry the job reporting the original exception
-    # 7. Because the job failed and Sidekiq can be managed by rollbar we'll
-    #    report a new exception.
-    # 8. Go to point 2.
-    #
-    # We'll then push to Sidekiq queue indefinitely until the network failure
-    # is fixed.
-    #
-    # Using Rollbar.silenced we avoid the above behavior but Sidekiq
-    # will have a chance to retry the original job.
-    def process_from_async_handler(payload)
-      payload = Rollbar::JSON.load(payload) if payload.is_a?(String)
-
-      item = Item.build_with(payload,
-                             :notifier => self,
-                             :configuration => configuration,
-                             :logger => logger)
-
-      Rollbar.silenced do
-        begin
-          process_item(item)
-        rescue => e
-          report_internal_error(e)
-
-          raise
-        end
-      end
-    end
-
-    def send_failsafe(message, exception)
-      exception_reason = failsafe_reason(message, exception)
-
-      log_error "[Rollbar] Sending failsafe response due to #{exception_reason}"
-
-      body = failsafe_body(exception_reason)
-
-      failsafe_data = {
-        :level => 'error',
-        :environment => configuration.environment.to_s,
-        :body => {
-          :message => {
-            :body => body
-          }
-        },
-        :notifier => {
-          :name => 'rollbar-gem',
-          :version => VERSION
-        },
-        :internal => true,
-        :failsafe => true
-      }
-
-      failsafe_payload = {
-        'access_token' => configuration.access_token,
-        'data' => failsafe_data
-      }
-
-      begin
-        item = Item.build_with(failsafe_payload,
-                               :notifier => self,
-                               :configuration => configuration,
-                               :logger => logger)
-        schedule_item(item)
-      rescue => e
-        log_error "[Rollbar] Error sending failsafe : #{e}"
-      end
-
-      failsafe_payload
-    end
-
-    private
-
-    def call_before_process(options)
-      options = {
-        :level => options[:level],
-        :scope => scope_object,
-        :exception => options[:exception],
-        :message => options[:message],
-        :extra => options[:extra]
-      }
-      handlers = configuration.before_process
-
-      handlers.each do |handler|
-        begin
-          handler.call(options)
-        rescue Rollbar::Ignore
-          raise
-        rescue => e
-          log_error("[Rollbar] Error calling the `before_process` hook: #{e}")
-
-          break
-        end
-      end
-    end
-
-    def extract_arguments(args)
-      message = nil
-      exception = nil
-      extra = nil
-
-      args.each do |arg|
-        if arg.is_a?(String)
-          message = arg
-        elsif arg.is_a?(Exception)
-          exception = arg
-        elsif arg.is_a?(Hash)
-          extra = arg
-        end
-      end
-
-      [message, exception, extra]
-    end
-
-    def lookup_exception_level(orig_level, exception, use_exception_level_filters)
-      return orig_level unless use_exception_level_filters
-
-      exception_level = filtered_level(exception)
-      return exception_level if exception_level
-
-      orig_level
-    end
-
-    def ignored?(exception, use_exception_level_filters = false)
-      return false unless exception
-      return true if use_exception_level_filters && filtered_level(exception) == 'ignore'
-      return true if exception.instance_variable_get(:@_rollbar_do_not_report)
-
-      false
-    end
-
-    def filtered_level(exception)
-      return unless exception
-
-      filter = configuration.exception_level_filters[exception.class.name]
-      if filter.respond_to?(:call)
-        filter.call(exception)
-      else
-        filter
-      end
-    end
-
-    def report(level, message, exception, extra)
-      unless message || exception || extra
-        log_error '[Rollbar] Tried to send a report with no message, exception or extra data.'
-
-        return 'error'
-      end
-
-      item = build_item(level, message, exception, extra)
-
-      return 'ignored' if item.ignored?
-
-      schedule_item(item)
-
-      data = item['data']
-      log_instance_link(data)
-      Rollbar.last_report = data
-
-      data
-    end
-
-    # Reports an internal error in the Rollbar library. This will be reported within the configured
-    # Rollbar project. We'll first attempt to provide a report including the exception traceback.
-    # If that fails, we'll fall back to a more static failsafe response.
-    def report_internal_error(exception)
-      log_error "[Rollbar] Reporting internal error encountered while sending data to Rollbar."
-
-      begin
-        item = build_item('error', nil, exception, {:internal => true})
-      rescue => e
-        send_failsafe("build_item in exception_data", e)
-        return
-      end
-
-      begin
-        process_item(item)
-      rescue => e
-        send_failsafe("error in process_item", e)
-        return
-      end
-
-      begin
-        log_instance_link(item['data'])
-      rescue => e
-        send_failsafe("error logging instance link", e)
-        return
-      end
-    end
-
-    ## Payload building functions
-
-    def build_item(level, message, exception, extra)
-      options = {
-        :level => level,
-        :message => message,
-        :exception => exception,
-        :extra => extra,
-        :configuration => configuration,
-        :logger => logger,
-        :scope => scope_object,
-        :notifier => self
-      }
-
-      item = Item.new(options)
-      item.build
-
-      item
-    end
-
-    ## Delivery functions
-
-    def send_item_using_eventmachine(item)
-      body = item.dump
-      return unless body
-
-      headers = { 'X-Rollbar-Access-Token' => item['access_token'] }
-      req = EventMachine::HttpRequest.new(configuration.endpoint).post(:body => body, :head => headers)
-
-      req.callback do
-        if req.response_header.status == 200
-          log_info '[Rollbar] Success'
-        else
-          log_warning "[Rollbar] Got unexpected status code from Rollbar.io api: #{req.response_header.status}"
-          log_info "[Rollbar] Response: #{req.response}"
-        end
-      end
-
-      req.errback do
-        log_warning "[Rollbar] Call to API failed, status code: #{req.response_header.status}"
-        log_info "[Rollbar] Error's response: #{req.response}"
-      end
-    end
-
-    def send_item(item)
-      log_info '[Rollbar] Sending item'
-
-      if configuration.use_eventmachine
-        send_item_using_eventmachine(item)
-        return
-      end
-
-      body = item.dump
-      return unless body
-
-      uri = URI.parse(configuration.endpoint)
-
-      handle_response(do_post(uri, body, item['access_token']))
-    end
-
-    def do_post(uri, body, access_token)
-      http = Net::HTTP.new(uri.host, uri.port)
-      http.open_timeout = configuration.open_timeout
-      http.read_timeout = configuration.request_timeout
-
-      if uri.scheme == 'https'
-        http.use_ssl = true
-        # This is needed to have 1.8.7 passing tests
-        http.ca_file = ENV['ROLLBAR_SSL_CERT_FILE'] if ENV.has_key?('ROLLBAR_SSL_CERT_FILE')
-        http.verify_mode = ssl_verify_mode
-      end
-
-      request = Net::HTTP::Post.new(uri.request_uri)
-
-      request.body = body
-      request.add_field('X-Rollbar-Access-Token', access_token)
-
-      handle_net_retries { http.request(request) }
-    end
-
-    def handle_net_retries
-      return yield if skip_retries?
-
-      retries = configuration.net_retries - 1
-
-      begin
-        yield
-      rescue *LanguageSupport.timeout_exceptions
-        raise if retries <= 0
-
-        retries -= 1
-
-        retry
-      end
-    end
-
-    def skip_retries?
-      Rollbar::LanguageSupport.ruby_18? || Rollbar::LanguageSupport.ruby_19?
-    end
-
-    def handle_response(response)
-      if response.code == '200'
-        log_info '[Rollbar] Success'
-      else
-        log_warning "[Rollbar] Got unexpected status code from Rollbar api: #{response.code}"
-        log_info "[Rollbar] Response: #{response.body}"
-      end
-    end
-
-    def ssl_verify_mode
-      if configuration.verify_ssl_peer
-        OpenSSL::SSL::VERIFY_PEER
-      else
-        OpenSSL::SSL::VERIFY_NONE
-      end
-    end
-
-    def write_item(item)
-      if configuration.use_async
-        @file_semaphore.synchronize {
-          do_write_item(item)
-        }
-      else
-        do_write_item(item)
-      end
-    end
-
-    def do_write_item(item)
-      log_info '[Rollbar] Writing item to file'
-
-      body = item.dump
-      return unless body
-
-      begin
-        unless @file
-          @file = File.open(configuration.filepath, "a")
-        end
-
-        @file.puts(body)
-        @file.flush
-        log_info "[Rollbar] Success"
-      rescue IOError => e
-        log_error "[Rollbar] Error opening/writing to file: #{e}"
-      end
-    end
-
-    def failsafe_reason(message, exception)
-      body = ''
-
-      if exception
-        begin
-          backtrace = exception.backtrace || []
-          nearest_frame = backtrace[0]
-
-          exception_info = exception.class.name
-          # #to_s and #message defaults to class.to_s. Add message only if add valuable info.
-          exception_info += %Q{: "#{exception.message}"} if exception.message != exception.class.to_s
-          exception_info += " in #{nearest_frame}" if nearest_frame
-
-          body += "#{exception_info}: #{message}"
-        rescue
-        end
-      else
-        begin
-          body += message.to_s
-        rescue
-        end
-      end
-
-      body
-    end
-
-    def failsafe_body(reason)
-      "Failsafe from rollbar-gem. #{reason}"
-    end
-
-    def schedule_item(item)
-      return unless item
-
-      log_info '[Rollbar] Scheduling item'
-
-      if configuration.use_async
-        process_async_item(item)
-      else
-        process_item(item)
-      end
-    end
-
-    def default_async_handler
-      return Rollbar::Delay::GirlFriday if defined?(GirlFriday)
-
-      Rollbar::Delay::Thread
-    end
-
-    def process_async_item(item)
-      configuration.async_handler ||= default_async_handler
-      configuration.async_handler.call(item.payload)
-    rescue => e
-      if configuration.failover_handlers.empty?
-        log_error '[Rollbar] Async handler failed, and there are no failover handlers configured. See the docs for "failover_handlers"'
-        return
-      end
-
-      async_failover(item)
-    end
-
-    def async_failover(item)
-      log_warning '[Rollbar] Primary async handler failed. Trying failovers...'
-
-      failover_handlers = configuration.failover_handlers
-
-      failover_handlers.each do |handler|
-        begin
-          handler.call(item.payload)
-        rescue
-          next unless handler == failover_handlers.last
-
-          log_error "[Rollbar] All failover handlers failed while processing item: #{Rollbar::JSON.dump(item.payload)}"
-        end
-      end
-    end
-
-    ## Logging
-    %w(debug info warn error).each do |level|
-      define_method(:"log_#{level}") do |message|
-        logger.send(level, message)
-      end
-    end
-
-    alias_method :log_warning, :log_warn
-
-    def log_instance_link(data)
-      if data[:uuid]
-        uuid_url = Util.uuid_rollbar_url(data, configuration)
-        log_info "[Rollbar] Details: #{uuid_url} (only available if report was successful)"
-      end
-    end
-
-    def logger
-      @logger ||= LoggerProxy.new(configuration.logger)
-    end
-  end
+                               process_item process_from_async_handler scope
+                               send_failsafe log_info log_debug log_warning
+                               log_error silenced scope_object with_config).freeze
 
   class << self
     extend Forwardable
@@ -646,43 +32,57 @@ module Rollbar
     def_delegators :notifier, *PUBLIC_NOTIFIER_METHODS
 
     attr_writer :plugins
+    attr_writer :root_notifier
 
-    # Similar to configure below, but used only internally within the gem
-    # to configure it without initializing any of the third party hooks
-    def preconfigure
-      yield(configuration)
+    def notifier
+      # Use the global instance @root_notifier so we don't fall
+      # in a infinite loop
+      Thread.current[:_rollbar_notifier] ||= Notifier.new(@root_notifier)
+    end
 
-      reset_notifier!
+    def notifier=(notifier)
+      Thread.current[:_rollbar_notifier] = notifier
     end
 
-    def configure
-      # if configuration.enabled has not been set yet (is still 'nil'), set to true.
-      configuration.enabled = true if configuration.enabled.nil?
+    # It's the first notifier instantiated in the
+    # process. We store it so all the next per-thread
+    # notifiers can inherit its configuration
+    # The methods Rollbar.configure, Rollbar.reconfigure,
+    # Rollbar.preconfigure and Rollbar.unconfigure work
+    # on this notifier.
+    # Before v2.13.0 these methods worked on the global
+    # configuration, so in the practice the behavior is the same,
+    # since they work on the root notifier's configuration
+    def root_notifier
+      @root_notifier ||= notifier
+    end
+
+    def preconfigure(&block)
+      root_notifier.preconfigure(&block)
+    end
 
-      yield(configuration)
+    # Configures the root notifier and loads the plugins
+    def configure(&block)
+      root_notifier.configure(&block)
 
       plugins.load!
-      reset_notifier!
     end
 
-    def reconfigure
-      @configuration = Configuration.new
-      @configuration.enabled = true
-      yield(configuration)
-
-      reset_notifier!
+    # Reconfigures the root notifier
+    def reconfigure(&block)
+      root_notifier.reconfigure(&block)
     end
 
+    # Unconfigures the root notifier
     def unconfigure
-      @configuration = nil
+      root_notifier.unconfigure
     end
 
+    # Returns the configuration for the current notifier.
+    # The current notifier is Rollbar.notifier and exists
+    # one per thread.
     def configuration
-      @configuration ||= Configuration.new
-    end
-
-    def scope_object
-      @scope_obejct ||= ::Rollbar::LazyStore.new({})
+      notifier.configuration
     end
 
     def safely?
@@ -693,14 +93,6 @@ module Rollbar
       @plugins ||= Rollbar::Plugins.new
     end
 
-    def notifier
-      Thread.current[:_rollbar_notifier] ||= Notifier.new(self)
-    end
-
-    def notifier=(notifier)
-      Thread.current[:_rollbar_notifier] = notifier
-    end
-
     def last_report
       Thread.current[:_rollbar_last_report]
     end
@@ -709,8 +101,24 @@ module Rollbar
       Thread.current[:_rollbar_last_report] = report
     end
 
+    # Resets the scope for the current thread notifier. The notifier
+    # reference is kept so we reuse the notifier.
+    # This is a change from version 2.13.0. Before this version
+    # this method clears the notifier.
+    #
+    # It was used in order to reset the scope and reusing the global
+    # configuration Rollbar.configuration. Since now Rollbar.configuration
+    # points to the current notifier configuration, we can resue the
+    # notifier instance and just reset the scope.
     def reset_notifier!
+      notifier.reset!
+    end
+
+    # Clears the current thread notifier and the root notifier.
+    # In the practice this should be used only on the specs
+    def clear_notifier!
       self.notifier = nil
+      self.root_notifier = nil
     end
 
     # Create a new Notifier instance using the received options and
@@ -721,16 +129,18 @@ module Rollbar
     # @example
     #
     #   new_scope = { job_type: 'scheduled' }
-    #   Rollbar.scoped(new_scope) do
+    #   new_config = { use_async: false }
+    #
+    #   Rollbar.scoped(new_scope, new_config) do
     #     begin
     #       # do stuff
     #     rescue => e
-    #       Rollbar.log(e)
+    #       Rollbar.error(e)
     #     end
     #   end
-    def scoped(options = {})
+    def scoped(options = {}, config_overrides = {})
       old_notifier = notifier
-      self.notifier = old_notifier.scope(options)
+      self.notifier = old_notifier.scope(options, config_overrides)
 
       result = yield
       result
@@ -738,6 +148,12 @@ module Rollbar
       self.notifier = old_notifier
     end
 
+    # Create a new Notifier instance with a new configuration
+    # using the current one but merging the passed options.
+    def with_config(overrides, &block)
+      scoped(nil, overrides, &block)
+    end
+
     def scope!(options = {})
       notifier.scope!(options)
     end