rollbar 1.1.0 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 6ba9f625302b093e422f24c2c3a35a7e6388c099
-  data.tar.gz: ef53f6cd97ed94d5db499b77c496a81f6c6eb6f8
+  metadata.gz: 850b8631306eb9e7c4e7379f869f573d74202b18
+  data.tar.gz: 10bbd67bc34a4635d5455b66c468bc3a4c65ce24
 SHA512:
-  metadata.gz: 5752f3f6282c97ffce3142bd39089946eb79f0f7a9a864f9be56f74ec563ebc49b0839a92eb4388ef5d0445cc6f1fb80ae7ffc28860811e6884c5abf50257457
-  data.tar.gz: c00267db9b445b402c2a84b3b608a3b3c23c17371611467ed79a173a1b6eb45a02f2e6d496c2b8131da45750cccb14723c55d61810ed6c65a82f1fa97d41231b
+  metadata.gz: 49809c4c002ff8a03d78b3c2b785bbf124ea754f4f54d668bf17bce21ab3bd9298fe9a15a09da2d50ba75b4ff7a6a03b03b601c1400aba6f2073c58128f49c4f
+  data.tar.gz: 204ec3d976719a22aa6333347d623ba17723d8574c2ab1c3b815f88631ebc996d3c4426619bbd8c8ddd88d34bab8a5a026cb9de0ed7f64d5c1202fca2d3d9408

data/CHANGELOG.md

@@ -1,8 +1,13 @@
 # Change Log
 
+**1.2.0**
+- Added new, much nicer interface for sending exceptions and messages to Rollbar. This is a backwards-compatible release: the old interface (`report_message`, `report_exception`, `report_message_with_request`) is deprecated but will continue to work at least until 2.0.
+  
+  See the docs for [basic](https://github.com/rollbar/rollbar-gem#caught-exceptions-and-messages) and [advanced](https://github.com/rollbar/rollbar-gem#advanced-usage) usage for a guide to the new interface. If you've used [rollbar.js](https://github.com/rollbar/rollbar.js), it will be familiar.
+
 **1.1.0**
+- Support nested exceptions for Ruby 2.1. See [#136](https://github.com/rollbar/rollbar-gem/pull/136). NOTE: for exceptions that have causes, this will change how they are grouped in Rollbar. If you have custom grouping rules, they will need to be updated to replace `body.trace.exception` with `body.trace_chain[0].exception` to maintain the same behavior for these exceptions.
 - New feature: `failover_handlers`. You can specify a list of async handlers, which will be tried in sequence upon failure. See [#135](https://github.com/rollbar/rollbar-gem/pull/135).
-- Support nested exceptions for Ruby 2.1. See [#136](https://github.com/rollbar/rollbar-gem/pull/136)
 - Fix handling of utf8 sequences in payload symbols. See [#131](https://github.com/rollbar/rollbar-gem/pull/131). Thanks [@kroky](https://github.com/kroky) for the fix and [@jondeandres](https://github.com/jondeandres) for reviewing.
 - Fix logic bugs in assignments for `scrub_fields` and `scrub_headers`. See [#137](https://github.com/rollbar/rollbar-gem/pull/137)
 

data/README.md

@@ -9,21 +9,19 @@ Ruby gem for reporting exceptions, errors, and log messages to [Rollbar](https:/
 
 Add this line to your application's Gemfile:
 
-    gem 'rollbar', '~> 1.1.0'
+    gem 'rollbar', '~> 1.2.0'
 
 And then execute:
 
 ```bash
 $ bundle install
-```
-
-Or install it yourself as:
-
-```bash
+# Or if you don't use bundler:
 $ gem install rollbar
 ```
 
-Then, run the following command from your rails root:
+### If using Rails
+
+Run the following command from your Rails root:
 
 ```bash
 $ rails generate rollbar POST_SERVER_ITEM_ACCESS_TOKEN
@@ -32,22 +30,20 @@ $ rails generate rollbar POST_SERVER_ITEM_ACCESS_TOKEN
 <!-- RemoveNextIfProject -->
 Be sure to replace ```POST_SERVER_ITEM_ACCESS_TOKEN``` with your project's ```post_server_item``` access token, which you can find in the Rollbar.com interface.
 
+That's all you need to use Rollbar with Rails.
 
 That will create the file ```config/initializers/rollbar.rb```, which holds the configuration values (currently just your access token).
 
-If you want to store your access token outside of your repo, run the same command without arguments:
+If you want to store your access token outside of your repo, run the same command without arguments, and create an environment variable ```ROLLBAR_ACCESS_TOKEN``` that holds your server-side access token:
 
 ```bash
 $ rails generate rollbar
-```
-
-Then, create an environment variable ```ROLLBAR_ACCESS_TOKEN``` and set it to your server-side access token.
-
-```bash
 $ export ROLLBAR_ACCESS_TOKEN=POST_SERVER_ITEM_ACCESS_TOKEN
 ```
 
-### For Heroku users
+For Heroku users:
+
+If you're on Heroku, you can store the access token in your Heroku config:
 
 ```bash
 $ heroku config:add ROLLBAR_ACCESS_TOKEN=POST_SERVER_ITEM_ACCESS_TOKEN
@@ -55,6 +51,22 @@ $ heroku config:add ROLLBAR_ACCESS_TOKEN=POST_SERVER_ITEM_ACCESS_TOKEN
 
 That's all you need to use Rollbar with Rails.
 
+### If not using Rails
+
+Be sure to initialize Rollbar with your access token somewhere during startup:
+
+```ruby
+Rollbar.configure do |config|
+  config.access_token = POST_SERVER_ITEM_ACCESS_TOKEN
+  # other configuration settings
+  # ...
+end
+```
+
+
+<!-- RemoveNextIfProject -->
+Be sure to replace ```POST_SERVER_ITEM_ACCESS_TOKEN``` with your project's ```post_server_item``` access token, which you can find in the Rollbar.com interface.
+
 ## Test your installation
 
 To confirm that it worked, run:
@@ -65,7 +77,50 @@ $ rake rollbar:test
 
 This will raise an exception within a test request; if it works, you'll see a stacktrace in the console, and the exception will appear in the Rollbar dashboard.
 
-## Reporting form validation errors
+## Usage
+
+### Uncaught exceptions
+
+Uncaught exceptions in Rails controllers will be automatically reported to Rollbar.
+
+### Caught exceptions and messages
+
+You can use one of `Rollbar.log(level, ...)`, `Rollbar.debug()`, `Rollbar.info()`, `Rollbar.warning()`, `Rollbar.error()` and `Rollbar.critical()` to report exceptions and messages.
+
+The methods take in any number of arguments, but the last exception is used as the reported exception, the last string is used as the message/description, and the last hash is used as the extra data.
+
+For example:
+
+```ruby
+begin
+  result = user_info[:key1][:key2][:key3]
+rescue NoMethodError => e
+  # simple exception report (level can be 'debug', 'info', 'warning', 'error' and 'critical')
+  Rollbar.log('error', e)
+  
+  # same functionality as above
+  Rollbar.error(e)
+  
+  # with a description
+  Rollbar.error(e, 'The user info hash doesn\'t contain the correct data')
+  
+  # with extra data giving more insight about the exception
+  Rollbar.error(e, :user_info => user_info, :job_id => job_id)
+end
+```
+
+You can also log individual messages:
+
+```ruby
+Rollbar.warning('Unexpected input')
+
+# can also include extra data
+Rollbar.info("Login successful", :username => @username)
+
+Rollbar.log('debug', 'Settings saved', :account_id => account.id)
+```
+
+### Reporting form validation errors
 
 To get form validation errors automatically reported to Rollbar just add the following ```after_validation``` callback to your models:
 
@@ -73,59 +128,97 @@ To get form validation errors automatically reported to Rollbar just add the fol
 after_validation :report_validation_errors_to_rollbar
 ```
 
-## Manually reporting exceptions and messages
+### Advanced usage
+
+You can use `Rollbar.scope()` to copy a notifier instance and customize the payload data for one-off reporting. The hash argument to `scope()` will be merged into the copied notifier's "payload options", a hash that will be merged into the final payload just before it is reported to Rollbar. 
 
-To report a caught exception to Rollbar, simply call ```Rollbar.report_exception```:
+For example:
 
 ```ruby
-begin
-  foo = bar
-rescue Exception => e
-  Rollbar.report_exception(e)
+while job
+  user = job.user
+
+  # Overwrites any existing person data
+  notifier = Rollbar.scope({
+    :person => {:id => user.id, :username => user.username, :email => user.email}
+  })
+
+  begin
+    job.do_work
+  rescue => e
+    # Sends a report with the above person data
+    notifier.critical(e)
+  end
+
+  job = next_job
 end
+
+# Wipe person data
+notifier = notifier.scope({
+  :person => nil
+})
+
+# No associated person data
+notifier.info('Jobs processed')
 ```
 
-If you're reporting an exception in the context of a request and are in a controller, you can pass along the same request and person context as the global exception handler, like so:
+If you don't want to work with a new `Notifier` instance `#scoped` will do it for you:
 
 ```ruby
-begin
-  foo = bar
-rescue Exception => e
-  Rollbar.report_exception(e, rollbar_request_data, rollbar_person_data)
+while job
+  user = job.user
+
+  # Overwrites any existing person data
+  scope = {
+    :person => {:id => user.id, :username => user.username, :email => user.email}
+  }
+
+  Rollbar.scoped(scope) do
+    begin
+      job.do_work
+    rescue => e
+      # Sends a report with the above person data
+      Rollbar.critical(e)
+    end
+  end
+
+  job = next_job
 end
 ```
 
-Exceptions are reported with an "error" level by default. You can override the level by passing it in as the fourth argument:
+## Person tracking
+
+Rollbar will send information about the current user (called a "person" in Rollbar parlance) along with each error report, when available. This works by calling the ```current_user``` controller method. The return value should be an object with an ```id``` method and, optionally, ```username``` and ```email``` methods.
+
+This will happen automatically for uncaught Rails exceptions and for any manual exception or log reporting done within a Rails request.
+
+If the gem should call a controller method besides ```current_user```, add the following in ```config/initializers/rollbar.rb```:
 
 ```ruby
-begin
-  foo = bar
-rescue Exception => e
-  # all levels: debug, info, warning, error, critical
-  Rollbar.report_exception(e, rollbar_request_data, rollbar_person_data, "warning")
+Rollbar.configure do |config|
+  config.person_method = "my_current_user"
 end
-
 ```
 
-You can also log individual messages:
+If the methods to extract the ```id```, ```username```, and ```email``` from the object returned by the ```person_method``` have other names, configure like so in ```config/initializers/rollbar.rb```:
 
 ```ruby
-Rollbar.report_message("Unexpected input", "warning")
+Rollbar.configure do |config|
+  config.person_id_method = "user_id"  # default is "id"
+  config.person_username_method = "user_name"  # default is "username"
+  config.person_email_method = "email_address"  # default is "email"
+end
+```
 
-# default level is "info"
-Rollbar.report_message("Login successful")
+## Special note about reporting within a request
 
-# can also include additional data as a hash in the final param. :body is reserved.
-Rollbar.report_message("Login successful", "info", :username => @username)
+The gem instantiates one `Notifier` instance on initialization, which will be the base notifier that is used for all reporting (via a `method_missing` proxy in the `Rollbar` module). Calling `Rollbar.configure()` will configure this base notifier that will be used globally in a ruby app.
 
-# pass request and person data
-Rollbar.report_message_with_request("Settings saved", "debug", rollbar_request_data,
-                                    rollbar_person_data, :account_id => account.id)
-```
+However, the Rails middleware will actually scope this base notifier for use within a request by storing it in thread-local storage (see [here](https://github.com/rollbar/rollbar-gem/blob/5f4e6135f0e61148672b0190c88767aa52e5cdb3/lib/rollbar/middleware/rails/rollbar.rb#L35-L39)). This is done to make any manual logging within a request automatically contain request and person data. Calling `Rollbar.configure()` therefore will only affect the notifier for the duration of the request, and not the base notifier used globally.
 
 ## Data sanitization (scrubbing)
 
-By default, the notifier will "scrub" the following fields from requests before sending to Rollbar
+By default, the notifier will "scrub" the following fields from payloads before sending to Rollbar
 
 - ```:passwd```
 - ```:password```
@@ -155,34 +248,9 @@ And ```Rollbar.configuration.scrub_headers```:
 Rollbar.configuration.scrub_headers |= ["X-Access-Token"]
 ```
 
-
-## Person tracking
-
-Rollbar will send information about the current user (called a "person" in Rollbar parlance) along with each error report, when available. This works by calling the ```current_user``` controller method. The return value should be an object with an ```id``` method and, optionally, ```username``` and ```email``` methods.
-
-If the gem should call a controller method besides ```current_user```, add the following in ```config/initializers/rollbar.rb```:
-
-```ruby
-config.person_method = "my_current_user"
-```
-
-If the methods to extract the ```id```, ```username```, and ```email``` from the object returned by the ```person_method``` have other names, configure like so in ```config/initializers/rollbar.rb```:
-
-```ruby
-config.person_id_method = "user_id"  # default is "id"
-config.person_username_method = "user_name"  # default is "username"
-config.person_email_method = "email_address"  # default is "email"
-```
-
-### If using Rails and not ActiveRecord
-
-By default, the `Rollbar::Middleware::Rails::RollbarRequestStore` middleware is inserted just before the `ActiveRecord::ConnectionAdapters::ConnectionManagement` middleware if `ActiveRecord` is defined. This middleware ensures that any database calls needed to grab person data are executed before connections are cleaned up in the `ConnectionManagement` middleware.
-
-If you are not using `ActiveRecord`, make sure you include the `RollbarRequestStore` middleware before any middlewares that do similar connection clean up.
-
 ## Including additional runtime data
 
-You can provide a lambda that will be called for each exception or message report.  ```custom_data_method``` should be a lambda that takes no arguments and returns a hash.
+You can provide a callable that will be called for each exception or message report.  ```custom_data_method``` should be a lambda that takes no arguments and returns a hash.
 
 Add the following in ```config/initializers/rollbar.rb```:
 
@@ -196,7 +264,7 @@ This data will appear in the Occurrences tab and on the Occurrence Detail pages
 
 ## Exception level filters
 
-By default, all exceptions reported through ```Rollbar.report_exception()``` are reported at the "error" level, except for the following, which are reported at "warning" level:
+By default, all uncaught exceptions are reported at the "error" level, except for the following, which are reported at "warning" level:
 
 - ```ActiveRecord::RecordNotFound```
 - ```AbstractController::ActionNotFound```
@@ -427,6 +495,10 @@ Check out [resque-rollbar](https://github.com/dimko/resque-rollbar) for using Ro
 
 Some users have reported problems with Zeus when ```rake``` was not explicitly included in their Gemfile. If the zeus server fails to start after installing the rollbar gem, try explicitly adding ```gem 'rake'``` to your ```Gemfile```. See [this thread](https://github.com/rollbar/rollbar-gem/issues/30) for more information.
 
+## Backwards Compatibility
+
+You can find upgrading notes in [UPGRADING.md](UPGRADING.md).
+
 
 ## Help / Support
 

data/UPGRADING.md

@@ -0,0 +1,45 @@
+# Upgrading
+
+## From 1.1.0 or lower to 1.2.0
+
+The public interface has been rewritten entirely in 1.2.0 to be more versatile and in-line with the new interface established recently in rollbar.js. The main `#report_message` and `#report_exception` methods are now deprecated in favor of the new `#log`, `#debug` `#info`, `#warn`, `#error` and `#critical` methods.
+
+The new methods will accept any number of arguments. The last string argument is used as a message/description, the last exception argument is used as the reported exception, and the last hash is used as the extra data (except for `log` which requires an additional level string as the first argument).
+
+The old methods will still function properly but it is recommended to migrate to the new interface whenever possible. You can migrate simply by doing the following:
+
+1. Replace all occurrences of `#report_exception` with `#error`, or `#log` with a custom level if set in your existing `#report_exception` call.
+
+2. Replace all occurrences of `#report_message` and `#report_message_with_request` with the one of the logging methods `#debug` through `#critical`.
+
+3. The argument order can stay the same.
+
+If using a Rack application, `request_data` and `person_data` will not longer be required to be passed in when logging messages or exceptions. The Rack, Sinatra or Rails middleware is responsible to extract the data and pass it to Rollbar.
+
+If **not** using any Rack application, then you will need to use the `#scope` or `#scoped` method to set this data manually:
+
+```ruby
+notifier = Rollbar.scope({
+  :request => rollbar_request_data,
+  :person => rollbar_person_data
+})
+
+# will contain request parameters and person data
+notifier.warning('User submitted invalid form data')
+```
+
+The `#scoped`method allows to change the payload options for a specific code block. This is the method used by the Rack and Rails middlewares.
+
+```ruby
+scope = { :request => rollbar_request_data,
+	      :person => rollbar_person_data
+}
+
+Rollbar.scoped(scope) do
+  begin
+      # code that will raise
+  rescue => e
+    Rollbar.error(e)
+  end
+end
+```

data/lib/rollbar.rb

@@ -11,6 +11,7 @@ end
 
 require 'rollbar/version'
 require 'rollbar/configuration'
+require 'rollbar/logger_proxy'
 require 'rollbar/request_data_extractor'
 require 'rollbar/exception_reporter'
 require 'rollbar/active_record_extension' if defined?(ActiveRecord)
@@ -18,6 +19,7 @@ require 'rollbar/util'
 require 'rollbar/railtie' if defined?(Rails)
 require 'rollbar/delay/girl_friday'
 require 'rollbar/delay/thread'
+require 'rollbar/core_ext/thread'
 
 unless ''.respond_to? :encode
   require 'iconv'
@@ -25,8 +27,29 @@ end
 
 module Rollbar
   MAX_PAYLOAD_SIZE = 128 * 1024 #128kb
+  ATTACHMENT_CLASSES = %w[
+    ActionDispatch::Http::UploadedFile
+    Rack::Multipart::UploadedFile
+  ].freeze
+  PUBLIC_NOTIFIER_METHODS = %w(debug info warn warning error critical log logger
+                               process_payload scope send_failsafe log_info log_debug
+                               log_warning log_error silenced)
+
+  class Notifier
+    attr_accessor :configuration
+
+    def initialize(parent_notifier = nil, payload_options = nil)
+      if parent_notifier
+        @configuration = parent_notifier.configuration.clone
+
+        if payload_options
+          Rollbar::Util.deep_merge(@configuration.payload_options, payload_options)
+        end
+      else
+        @configuration = ::Rollbar::Configuration.new
+      end
+    end
 
-  class << self
     attr_writer :configuration
     attr_accessor :last_report
 
@@ -38,253 +61,131 @@ module Rollbar
       yield(configuration)
     end
 
-    # Configures the gem.
-    #
-    # Call on app startup to set the `access_token` (required) and other config params.
-    # In a Rails app, this is called by `config/initializers/rollbar.rb` which is generated
-    # with `rails generate rollbar access-token-here`
-    #
-    # @example
-    #   Rollbar.configure do |config|
-    #     config.access_token = 'abcdefg'
-    #   end
+    # Configures the notifier instance
     def configure
-      # if configuration.enabled has not been set yet (is still 'nil'), set to true.
       configuration.enabled = true if configuration.enabled.nil?
 
       yield(configuration)
-
-      require_hooks
     end
 
-    def reconfigure
-      @configuration = Configuration.new
-      @configuration.enabled = true
-      yield(configuration)
+    def scope(options = {})
+      self.class.new(self, options)
     end
 
-    def unconfigure
-      @configuration = nil
+    def configure
+      yield(configuration)
     end
 
-    # Returns the configuration object.
+    # Turns off reporting for the given block.
     #
-    # @return [Rollbar::Configuration] The configuration object
-    def configuration
-      @configuration ||= Configuration.new
+    # @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
 
-    # Reports an exception to Rollbar. Returns the exception data hash.
+    # 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.report_exception(e)
+    #     Rollbar.log(e)
     #   end
     #
-    # @param exception [Exception] The exception object to report
-    # @param request_data [Hash] Data describing the request. Should be the result of calling
-    #   `rollbar_request_data`.
-    # @param person_data [Hash] Data describing the affected person. Should be the result of calling
-    #   `rollbar_person_data`
-    def report_exception(exception, request_data = nil, person_data = nil, level = nil)
-      if person_data
-        person_id = person_data[Rollbar.configuration.person_id_method.to_sym]
-        return 'ignored' if configuration.ignored_person_ids.include?(person_id)
-      end
-
-      return 'disabled' unless configuration.enabled
-      return 'ignored' if ignored?(exception)
-
-      data = exception_data(exception, level ? level : filtered_level(exception))
-
-      attach_request_data(data, request_data) if request_data
-      data[:person] = person_data if person_data
-
-      @last_report = data
-
-      payload = build_payload(data)
-      schedule_payload(payload)
-      log_instance_link(data)
-      data
-    rescue Exception => e
-      report_internal_error(e)
-      'error'
-    end
-
-    # Reports an arbitrary message to Rollbar
-    #
     # @example
-    #   Rollbar.report_message("User login failed", 'info', :user_id => 123)
-    #
-    # @param message [String] The message body. This will be used to identify the message within
-    #   Rollbar. For best results, avoid putting variables in the message body; pass them as
-    #   `extra_data` instead.
-    # @param level [String] The level. One of: 'critical', 'error', 'warning', 'info', 'debug'
-    # @param extra_data [Hash] Additional data to include alongside the body. Don't use 'body' as
-    #   it is reserved.
-    def report_message(message, level = 'info', extra_data = {})
-      return 'disabled' unless configuration.enabled
-
-      data = message_data(message, level, extra_data)
-
-      @last_report = data
-
-      payload = build_payload(data)
-      schedule_payload(payload)
-      log_instance_link(data)
-      data
-    rescue Exception => e
-      report_internal_error(e)
-      'error'
-    end
-
-    # Reports an arbitrary message to Rollbar with request and person data
+    #   Rollbar.log('This is a simple log message')
     #
     # @example
-    #   Rollbar.report_message_with_request("User login failed", 'info', rollbar_request_data, rollbar_person_data, :foo => 'bar')
+    #   Rollbar.log(e, 'This is a description of the exception')
     #
-    # @param message [String] The message body. This will be used to identify the message within
-    #   Rollbar. For best results, avoid putting variables in the message body; pass them as
-    #   `extra_data` instead.
-    # @param level [String] The level. One of: 'critical', 'error', 'warning', 'info', 'debug'
-    # @param request_data [Hash] Data describing the request. Should be the result of calling
-    #   `rollbar_request_data`.
-    # @param person_data [Hash] Data describing the affected person. Should be the result of calling
-    #   `rollbar_person_data`
-    # @param extra_data [Hash] Additional data to include alongside the body. Don't use 'body' as
-    #   it is reserved.
-    def report_message_with_request(message, level = 'info', request_data = nil, person_data = nil, extra_data = {})
+    def log(level, *args)
       return 'disabled' unless configuration.enabled
 
-      data = message_data(message, level, extra_data)
-
-      attach_request_data(data, request_data) if request_data
-      data[:person] = person_data if person_data
-
-      @last_report = data
+      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
 
-      payload = build_payload(data)
-      schedule_payload(payload)
-      log_instance_link(data)
-      data
-    rescue => e
-      report_internal_error(e)
-      'error'
-    end
+      return 'ignored' if ignored?(exception)
 
-    # Turns off reporting for the given block.
-    #
-    # @example
-    #   Rollbar.silenced { raise }
-    #
-    # @yield Block which exceptions won't be reported.
-    def silenced
       begin
-        yield
-      rescue => e
-        e.instance_variable_set(:@_rollbar_do_not_report, true)
-        raise
+        report(level, message, exception, extra)
+      rescue Exception => e
+        report_internal_error(e)
+        'error'
       end
     end
 
-    def process_payload(payload)
-      begin
-        if configuration.write_to_file
-          write_payload(payload)
-        else
-          send_payload(payload)
-        end
-      rescue => e
-        log_error "[Rollbar] Error processing payload: #{e}"
-      end
+    # See log() above
+    def debug(*args)
+      log('debug', *args)
     end
 
-    # wrappers around logger methods
-    def log_error(message)
-      begin
-        logger.error message
-      rescue => e
-        puts "[Rollbar] Error logging error:"
-        puts "[Rollbar] #{message}"
-      end
+    # See log() above
+    def info(*args)
+      log('info', *args)
     end
 
-    def log_info(message)
-      begin
-        logger.info message
-      rescue => e
-        puts "[Rollbar] Error logging info:"
-        puts "[Rollbar] #{message}"
-      end
+    # See log() above
+    def warn(*args)
+      log('warning', *args)
     end
 
-    def log_warning(message)
-      begin
-        logger.warn message
-      rescue => e
-        puts "[Rollbar] Error logging warning:"
-        puts "[Rollbar] #{message}"
-      end
+    # See log() above
+    def warning(*args)
+      log('warning', *args)
     end
 
-    def log_debug(message)
-      begin
-        logger.debug message
-      rescue => e
-        puts "[Rollbar] Error logging debug"
-        puts "[Rollbar] #{message}"
-      end
+    # See log() above
+    def error(*args)
+      log('error', *args)
     end
 
-    def default_async_handler
-      return Rollbar::Delay::GirlFriday if defined?(GirlFriday)
-
-      Rollbar::Delay::Thread
+    # See log() above
+    def critical(*args)
+      log('critical', *args)
     end
 
-    private
-
-    def attach_request_data(payload, request_data)
-      if request_data[:route]
-        route = request_data[:route]
-
-        # make sure route is a hash built by RequestDataExtractor in rails apps
-        if route.is_a?(Hash) and not route.empty?
-          payload[:context] = "#{request_data[:route][:controller]}" + '#' + "#{request_data[:route][:action]}"
+    def process_payload(payload)
+      if configuration.write_to_file
+        if configuration.use_async
+          @file_semaphore.synchronize {
+            write_payload(payload)
+          }
+        else
+          write_payload(payload)
         end
+      else
+        send_payload(payload)
       end
-
-      request_data[:env].reject!{|k, v| v.is_a?(IO) } if request_data[:env]
-      payload[:request] = request_data
-    end
-
-    def require_hooks()
-      if defined?(Delayed) && defined?(Delayed::Worker) && configuration.delayed_job_enabled
-        require 'rollbar/delayed_job'
-        Rollbar::Delayed::wrap_worker
-      end
-
-      require 'rollbar/sidekiq' if defined?(Sidekiq)
-      require 'rollbar/goalie' if defined?(Goalie)
-      require 'rollbar/rack' if defined?(Rack)
-      require 'rollbar/rake' if defined?(Rake)
-      require 'rollbar/better_errors' if defined?(BetterErrors)
     end
 
-    def log_instance_link(data)
-      log_info "[Rollbar] Details: #{configuration.web_base}/instance/uuid?uuid=#{data[:uuid]} (only available if report was successful)"
-    end
+    private
 
     def ignored?(exception)
-      if filtered_level(exception) == 'ignore'
-        return true
-      end
-
-      if exception.instance_variable_get(:@_rollbar_do_not_report)
-        return true
-      end
+      return false unless exception
+      return true if filtered_level(exception) == 'ignore'
+      return true if exception.instance_variable_get(:@_rollbar_do_not_report)
 
       false
     end
@@ -298,53 +199,114 @@ module Rollbar
       end
     end
 
-    def message_data(message, level, extra_data)
-      data = base_data(level)
+    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
 
-      data[:body] = {
-        :message => {
-          :body => message.to_s
-        }
-      }
-      data[:body][:message].merge!(extra_data)
-      data[:server] = server_data
+      payload = build_payload(level, message, exception, extra)
+      data = payload['data']
+      evaluate_payload(data)
+
+      if data[:person]
+        person_id = data[:person][configuration.person_id_method.to_sym]
+        return 'ignored' if configuration.ignored_person_ids.include?(person_id)
+      end
+
+      schedule_payload(payload)
+
+      log_instance_link(data)
+
+      Rollbar.last_report = data
 
       data
     end
 
-    def exception_data(exception, force_level = nil)
-      data = base_data
+    # 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."
 
-      data[:level] = force_level if force_level
+      begin
+        payload = build_payload('error', nil, exception, {:internal => true})
+      rescue => e
+        send_failsafe("build_payload in exception_data", e)
+        return
+      end
 
-      traces = trace_chain(exception)
+      begin
+        process_payload(payload)
+      rescue => e
+        send_failsafe("error in process_payload", e)
+        return
+      end
 
-      if traces.size > 1
-        body = {
-          :trace_chain => traces
-        }
-      elsif traces.size == 1
-        body = {
-          :trace => traces[0]
-        }
+      begin
+        log_instance_link(payload['data'])
+      rescue => e
+        send_failsafe("error logging instance link", e)
+        return
       end
+    end
 
-      data[:body] = body
+    ## Payload building functions
 
-      data[:server] = server_data
+    def build_payload(level, message, exception, extra)
+      environment = configuration.environment
+      environment = 'unspecified' if environment.nil? || environment.empty?
 
-      data
+      data = {
+        :timestamp => Time.now.to_i,
+        :environment => environment,
+        :level => level,
+        :language => 'ruby',
+        :framework => configuration.framework,
+        :server => server_data,
+        :notifier => {
+          :name => 'rollbar-gem',
+          :version => VERSION
+        }
+      }
+
+      data[:body] = build_payload_body(message, exception, extra)
+      data[:project_package_paths] = configuration.project_gem_paths if configuration.project_gem_paths
+      data[:code_version] = configuration.code_version if configuration.code_version
+      data[:uuid] = SecureRandom.uuid if defined?(SecureRandom) && SecureRandom.respond_to?(:uuid)
+
+      Rollbar::Util.deep_merge(data, configuration.payload_options)
+
+      {
+        'access_token' => configuration.access_token,
+        'data' => data
+      }
     end
 
-    def trace_chain(exception)
-      traces = [trace_data(exception)]
+    def build_payload_body(message, exception, extra)
+      unless configuration.custom_data_method.nil?
+        custom = Rollbar::Util.deep_copy(configuration.custom_data_method.call)
+        extra = Rollbar::Util.deep_merge(custom, extra || {})
+      end
 
-      while exception.respond_to?(:cause) && (cause = exception.cause)
-        traces << trace_data(cause)
-        exception = cause
+      if exception
+        build_payload_body_exception(message, exception, extra)
+      else
+        build_payload_body_message(message, extra)
       end
+    end
 
-      traces
+    def build_payload_body_exception(message, exception, extra)
+      traces = trace_chain(exception)
+
+      traces[0][:exception][:description] = message if message
+      traces[0][:extra] = extra if extra
+
+      if traces.size > 1
+        { :trace_chain => traces }
+      elsif traces.size == 1
+        { :trace => traces[0] }
+      end
     end
 
     def trace_data(exception)
@@ -374,37 +336,108 @@ module Rollbar
       }
     end
 
-    def logger
-      # init if not set
-      unless configuration.logger
-        configuration.logger = configuration.default_logger.call
+    def trace_chain(exception)
+      traces = [trace_data(exception)]
+
+      while exception.respond_to?(:cause) && (cause = exception.cause)
+        traces << trace_data(cause)
+        exception = cause
       end
-      configuration.logger
+
+      traces
     end
 
-    def write_payload(payload)
-      if configuration.use_async
-        @file_semaphore.synchronize {
-          do_write_payload(payload)
-        }
-      else
-        do_write_payload(payload)
+    def build_payload_body_message(message, extra)
+      result = { :body => message || 'Empty message'}
+      result[:extra] = extra if extra
+
+      { :message => result }
+    end
+
+    def server_data
+      data = {
+        :host => Socket.gethostname
+      }
+      data[:root] = configuration.root.to_s if configuration.root
+      data[:branch] = configuration.branch if configuration.branch
+
+      data
+    end
+
+    # Walks the entire payload and replaces callable values with
+    # their results
+    def evaluate_payload(payload)
+      evaluator = proc do |key, value|
+        result = value
+
+        if value.respond_to? :call
+          begin
+            result = value.call
+          rescue
+            log_error "[Rollbar] Error while evaluating callable in payload for key #{key}"
+            result = nil
+          end
+        end
+
+        result
       end
+
+      Rollbar::Util.iterate_and_update_hash(payload, evaluator)
     end
 
-    def do_write_payload(payload)
-      log_info '[Rollbar] Writing payload to file'
+    def enforce_valid_utf8(payload)
+      normalizer = lambda do |object|
+        is_symbol = object.is_a?(Symbol)
 
-      begin
-        unless @file
-          @file = File.open(configuration.filepath, "a")
+        return object unless object == object.to_s || is_symbol
+
+        value = object.to_s
+
+        if value.respond_to? :encode
+          encoded_value = value.encode('UTF-8', 'binary', :invalid => :replace, :undef => :replace, :replace => '')
+        else
+          encoded_value = ::Iconv.conv('UTF-8//IGNORE', 'UTF-8', value)
         end
 
-        @file.puts payload
-        @file.flush
-        log_info "[Rollbar] Success"
-      rescue IOError => e
-        log_error "[Rollbar] Error opening/writing to file: #{e}"
+        is_symbol ? encoded_value.to_sym : encoded_value
+      end
+
+      Rollbar::Util.iterate_and_update(payload, normalizer)
+    end
+
+    # Walks the entire payload and truncates string values that
+    # are longer than the byte_threshold
+    def truncate_payload(payload, byte_threshold)
+      truncator = proc do |value|
+        if value.is_a?(String) && value.bytesize > byte_threshold
+          Rollbar::Util.truncate(value, byte_threshold)
+        else
+          value
+        end
+      end
+
+      Rollbar::Util.iterate_and_update(payload, truncator)
+    end
+
+    ## Delivery functions
+
+    def schedule_payload(payload)
+      log_info '[Rollbar] Scheduling payload'
+
+      if configuration.use_async
+        unless configuration.async_handler
+          configuration.async_handler = method(:default_async_handler)
+        end
+
+        if configuration.write_to_file
+          unless @file_semaphore
+            @file_semaphore = Mutex.new
+          end
+        end
+
+        configuration.async_handler.call(payload)
+      else
+        process_payload(payload)
       end
     end
 
@@ -421,6 +454,7 @@ module Rollbar
           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}"
@@ -437,6 +471,7 @@ module Rollbar
       end
 
       body = dump_payload(payload)
+
       uri = URI.parse(configuration.endpoint)
       http = Net::HTTP.new(uri.host, uri.port)
       http.read_timeout = configuration.request_timeout
@@ -459,6 +494,72 @@ module Rollbar
       end
     end
 
+    def write_payload(payload)
+      if configuration.use_async
+        @file_semaphore.synchronize {
+          do_write_payload(payload)
+        }
+      else
+        do_write_payload(payload)
+      end
+    end
+
+    def do_write_payload(payload)
+      log_info '[Rollbar] Writing payload to file'
+
+      begin
+        unless @file
+          @file = File.open(configuration.filepath, "a")
+        end
+
+        @file.puts payload
+        @file.flush
+        log_info "[Rollbar] Success"
+      rescue IOError => e
+        log_error "[Rollbar] Error opening/writing to file: #{e}"
+      end
+    end
+
+    def send_failsafe(message, exception)
+      log_error "[Rollbar] Sending failsafe response due to #{message}."
+      if exception
+        begin
+          log_error "[Rollbar] #{exception.class.name}: #{exception}"
+        rescue => e
+        end
+      end
+
+      config = configuration
+      environment = config.environment
+
+      failsafe_data = {
+        :level => 'error',
+        :environment => environment.to_s,
+        :body => {
+          :message => {
+            :body => "Failsafe from rollbar-gem: #{message}"
+          }
+        },
+        :notifier => {
+          :name => 'rollbar-gem',
+          :version => VERSION
+        },
+        :internal => true,
+        :failsafe => true
+      }
+
+      failsafe_payload = {
+        'access_token' => configuration.access_token,
+        'data' => failsafe_data
+      }
+
+      begin
+        schedule_payload(failsafe_payload)
+      rescue => e
+        log_error "[Rollbar] Error sending failsafe : #{e}"
+      end
+    end
+
     def schedule_payload(payload)
       return if payload.nil?
 
@@ -471,10 +572,16 @@ module Rollbar
       end
     end
 
+    def default_async_handler
+      return Rollbar::Delay::GirlFriday if defined?(GirlFriday)
+
+      Rollbar::Delay::Thread
+    end
+
     def process_async_payload(payload)
       configuration.async_handler ||= default_async_handler
       configuration.async_handler.call(payload)
-    rescue
+    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
@@ -499,16 +606,6 @@ module Rollbar
       end
     end
 
-    def build_payload(data)
-      payload = {
-        'access_token' => configuration.access_token,
-        'data' => data
-      }
-
-      enforce_valid_utf8(payload)
-      payload
-    end
-
     def dump_payload(payload)
       result = MultiJson.dump(payload)
 
@@ -537,154 +634,153 @@ module Rollbar
       result
     end
 
-    def base_data(level = 'error')
-      config = configuration
-
-      environment = config.environment
-      if environment.nil? || environment.empty?
-        environment = 'unspecified'
+    ## Logging
+    %w(debug info warn error).each do |level|
+      define_method(:"log_#{level}") do |message|
+        logger.send(level, message)
       end
+    end
 
-      data = {
-        :timestamp => Time.now.to_i,
-        :environment => environment,
-        :level => level,
-        :language => 'ruby',
-        :framework => config.framework,
-        :project_package_paths => config.project_gem_paths,
-        :notifier => {
-          :name => 'rollbar-gem',
-          :version => VERSION
-        }
-      }
+    alias_method :log_warning, :log_warn
 
-      if config.code_version
-        data[:code_version] = config.code_version
+    def log_instance_link(data)
+      if data[:uuid]
+        log_info "[Rollbar] Details: #{configuration.web_base}/instance/uuid?uuid=#{data[:uuid]} (only available if report was successful)"
       end
+    end
 
-      if defined?(SecureRandom) and SecureRandom.respond_to?(:uuid)
-        data[:uuid] = SecureRandom.uuid
-      end
+    def logger
+      @logger ||= LoggerProxy.new(configuration.logger)
+    end
+  end
 
-      unless config.custom_data_method.nil?
-        data[:custom] = config.custom_data_method.call
-      end
+  class << self
+    extend Forwardable
 
-      data
+    def_delegators :notifier, *PUBLIC_NOTIFIER_METHODS
+
+    # 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
 
-    def server_data
-      config = configuration
+    def configure
+      # if configuration.enabled has not been set yet (is still 'nil'), set to true.
+      configuration.enabled = true if configuration.enabled.nil?
 
-      data = {
-        :host => Socket.gethostname
-      }
-      data[:root] = config.root.to_s if config.root
-      data[:branch] = config.branch if config.branch
+      yield(configuration)
 
-      data
+      require_hooks
     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."
+    def reconfigure
+      @configuration = Configuration.new
+      @configuration.enabled = true
+      yield(configuration)
+    end
 
-      begin
-        data = exception_data(exception, 'error')
-      rescue => e
-        send_failsafe("error in exception_data", e)
-        return
-      end
+    def unconfigure
+      @configuration = nil
+    end
 
-      data[:internal] = true
+    def configuration
+      @configuration ||= Configuration.new
+    end
 
-      begin
-        payload = build_payload(data)
-      rescue => e
-        send_failsafe("error in build_payload", e)
-        return
-      end
+    def require_hooks
+      wrap_delayed_worker
 
-      begin
-        schedule_payload(payload)
-      rescue => e
-        send_failsafe("error in schedule_payload", e)
-        return
-      end
+      require 'rollbar/sidekiq' if defined?(Sidekiq)
+      require 'rollbar/goalie' if defined?(Goalie)
+      require 'rollbar/rack' if defined?(Rack)
+      require 'rollbar/rake' if defined?(Rake)
+      require 'rollbar/better_errors' if defined?(BetterErrors)
+    end
 
-      begin
-        log_instance_link(data)
-      rescue => e
-        send_failsafe("error logging instance link", e)
-        return
-      end
+    def wrap_delayed_worker
+      return unless defined?(Delayed) && defined?(Delayed::Worker) && configuration.delayed_job_enabled
+
+      require 'rollbar/delayed_job'
+      Rollbar::Delayed.wrap_worker
     end
 
-    def send_failsafe(message, exception)
-      log_error "[Rollbar] Sending failsafe response due to #{message}."
-      if exception
-        begin
-          log_error "[Rollbar] #{exception.class.name}: #{exception}"
-        rescue => e
-        end
-      end
+    def notifier
+      Thread.current[:_rollbar_notifier] ||= Notifier.new(self)
+    end
 
-      config = configuration
-      environment = config.environment
+    def notifier=(notifier)
+      Thread.current[:_rollbar_notifier] = notifier
+    end
 
-      failsafe_data = {
-        :level => 'error',
-        :environment => "#{environment}",
-        :body => { :message => { :body => "Failsafe from rollbar-gem: #{message}" } },
-        :notifier => { :name => 'rollbar-gem', :version => "#{VERSION}" },
-        :internal => true,
-        :failsafe => true
-      }
+    def last_report
+      Thread.current[:_rollbar_last_report]
+    end
 
-      failsafe_payload = build_payload(failsafe_data)
+    def last_report=(report)
+      Thread.current[:_rollbar_last_report] = report
+    end
 
-      begin
-        schedule_payload(failsafe_payload)
-      rescue => e
-        log_error "[Rollbar] Error sending failsafe : #{e}"
-      end
+    def reset_notifier!
+      self.notifier = nil
     end
 
-    def enforce_valid_utf8(payload)
-      normalizer = lambda do |object|
-        is_symbol = object.is_a?(Symbol)
+    # Create a new Notifier instance using the received options and
+    # set it as the current thread notifier.
+    # The calls to Rollbar inside the received block will use then this
+    # new Notifier object.
+    #
+    # @example
+    #
+    #   new_scope = { job_type: 'scheduled' }
+    #   Rollbar.scoped(new_scope) do
+    #     begin
+    #       # do stuff
+    #     rescue => e
+    #       Rollbar.log(e)
+    #     end
+    #   end
+    def scoped(options = {})
+      old_notifier = notifier
+      self.notifier = old_notifier.scope(options)
 
-        return object unless object == object.to_s || is_symbol
+      result = yield
+      result
+    ensure
+      self.notifier = old_notifier
+    end
 
-        value = object.to_s
+    # Backwards compatibility methods
 
-        if value.respond_to? :encode
-          encoded_value = value.encode('UTF-8', 'binary', :invalid => :replace, :undef => :replace, :replace => '')
-        else
-          encoded_value = ::Iconv.conv('UTF-8//IGNORE', 'UTF-8', value)
-        end
+    def report_exception(exception, request_data = {}, person_data = {}, level = 'error')
+      Kernel.warn('[DEPRECATION] Rollbar.report_exception has been deprecated, please use log() or one of the level functions')
 
-        is_symbol ? encoded_value.to_sym : encoded_value
+      scope = {}
+      scope[:request] = request_data if request_data && request_data.any?
+      scope[:person] = person_data if person_data && person_data.any?
+
+      Rollbar.scoped(scope) do
+        Rollbar.notifier.log(level, exception)
       end
+    end
 
-      Rollbar::Util.iterate_and_update(payload, normalizer)
+    def report_message(message, level = 'info', extra_data = {})
+      Kernel.warn('[DEPRECATION] Rollbar.report_message has been deprecated, please use log() or one of the level functions')
+
+      Rollbar.notifier.log(level, message, extra_data)
     end
 
-    def truncate_payload(payload, byte_threshold)
-      truncator = Proc.new do |value|
-        if value.is_a?(String) and value.bytesize > byte_threshold
-          Rollbar::Util::truncate(value, byte_threshold)
-        else
-          value
-        end
-      end
+    def report_message_with_request(message, level = 'info', request_data = {}, person_data = {}, extra_data = {})
+      Kernel.warn('[DEPRECATION] Rollbar.report_message_with_request has been deprecated, please use log() or one of the level functions')
+
+      scope = {}
+      scope[:request] = request_data if request_data && request_data.any?
+      scope[:person] = person_data if person_data && person_data.any?
 
-      Rollbar::Util::iterate_and_update(payload, truncator)
+
+      Rollbar.scoped(:request => request_data, :person => person_data) do
+        Rollbar.notifier.log(level, message, extra_data)
+      end
     end
   end
 end
-
-# Setting Ratchetio as an alias to Rollbar for ratchetio-gem backwards compatibility
-Ratchetio = Rollbar