rollbar 2.10.0 → 2.11.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a45a6459fbc4fdc48b10d24d8f789ac3dc6c712a
-  data.tar.gz: a6391231fe97e651db01a382a214c3f9cf002310
+  metadata.gz: 548fb68e7c723f07871b11f17bd587b828d52d28
+  data.tar.gz: 8709dde8c12f7d291bc9511dc0749a9cba5376bd
 SHA512:
-  metadata.gz: 75910ee630569144378fdc9bbb3039e514273e335b4b1fca19be9f02ad60158414e396a75e3ee01b05bc3053dd5efed95bb1a3a111357a03ee22c42a41539d69
-  data.tar.gz: 45fe74d97b172e168127fac6478d9eeca7e155018a95cc4df7c01aa6823868156297fddedef3da6df93404532604f64d174c2ce28cf2a551dafccf977f3e1873
+  metadata.gz: ce5a7b20e794752c03d21b479867b0a445eeb905dc23980bad4840beffd010de2c3f884e60eec0a5e4fef019288a6cc498a574aaf5a5161c9c54c8824982ab5d
+  data.tar.gz: c71dab677825a633bed1dd7aefba302fb1f87ed0e78fa309ca5a0af31e574982c9cc4310967935b8acfe25bf7c361184ffb0afe10ba5f2998de9d337a43f5221

data/.travis.yml

@@ -7,8 +7,6 @@ before_install:
   - gem update --system 2.1.11
   - gem --version
 rvm:
-  - 1.8.7
-  - 1.9.2
   - 1.9.3
   - 2.0.0
   - 2.1.0
@@ -32,6 +30,13 @@ gemfile:
   - gemfiles/rails42.gemfile
   - gemfiles/rails50.gemfile
 matrix:
+  include:
+    - rvm: 1.8.7
+      gemfile: gemfiles/ruby_1_8_and_1_9_2.gemfile
+      jdk: openjdk6
+    - rvm: 1.9.2
+      gemfile: gemfiles/ruby_1_8_and_1_9_2.gemfile
+      jdk: openjdk6
   allow_failures:
     - rvm: ruby-head
     - rvm: jruby-18mode

data/CHANGELOG.md

@@ -1,5 +1,25 @@
 # Change Log
 
+## 2.11.0
+
+New features:
+
+- Rollbar.js support wit 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:
+
+- Fix URL scrubbing and change to a functional object. See [#454](https://github.com/rollbar/rollbar-gem/pull/454).
+- Allow any argument for BasicSocket#as_json. See [#455](https://github.com/rollbar/rollbar-gem/pull/455).
+- Retry request on network timeouts. See [#453](https://github.com/rollbar/rollbar-gem/pull/453).
+
+Refactors and others:
+
+- Refactor Item payload building. See [#452](https://github.com/rollbar/rollbar-gem/pull/454).
+- 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).
+
 ## 2.10.0
 
 New features:

data/README.md

@@ -1,11 +1,68 @@
-# Rollbar notifier for Ruby [![Build Status](https://api.travis-ci.org/rollbar/rollbar-gem.svg?branch=v2.10.0)](https://travis-ci.org/rollbar/rollbar-gem/branches)
+# Rollbar [![Build Status](https://api.travis-ci.org/rollbar/rollbar-gem.svg?branch=v2.11.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.
 
 This is the Ruby library for Rollbar. It will instrument many kinds of Ruby applications automatically at the framework level. You can also make direct calls to send exceptions and messages to Rollbar.
 
-<!-- Sub:[TOC] -->
+<!-- START doctoc generated TOC please keep comment here to allow auto update -->
+<!-- DON'T EDIT THIS SECTION, INSTEAD RE-RUN doctoc TO UPDATE -->
+## Table of Contents
+
+- [Getting Started](#getting-started)
+  - [Rails](#rails)
+  - [Rack](#rack)
+  - [Plain Ruby](#plain-ruby)
+- [Integration with Rollbar.js](#integration-with-rollbarjs)
+- [Test your installation](#test-your-installation)
+- [Usage](#usage)
+  - [Uncaught exceptions](#uncaught-exceptions)
+  - [Caught exceptions and messages](#caught-exceptions-and-messages)
+  - [Reporting form validation errors](#reporting-form-validation-errors)
+  - [Advanced usage](#advanced-usage)
+- [Person tracking](#person-tracking)
+  - [Person tracking with Rack applications](#person-tracking-with-rack-applications)
+- [Special note about reporting within a request](#special-note-about-reporting-within-a-request)
+- [Data sanitization (scrubbing)](#data-sanitization-scrubbing)
+- [Including additional runtime data](#including-additional-runtime-data)
+- [Exception level filters](#exception-level-filters)
+- [Before process hook](#before-process-hook)
+- [Transform hook](#transform-hook)
+- [The Scope](#the-scope)
+- [Silencing exceptions at runtime](#silencing-exceptions-at-runtime)
+- [Sending backtrace without rescued exceptions](#sending-backtrace-without-rescued-exceptions)
+- [ActiveJob integration](#activejob-integration)
+- [Delayed::Job](#delayedjob)
+- [Asynchronous reporting](#asynchronous-reporting)
+  - [girl_friday](#girl_friday)
+  - [sucker_punch](#sucker_punch)
+  - [Sidekiq](#sidekiq)
+  - [Resque](#resque)
+  - [DelayedJob](#delayedjob)
+  - [Threading](#threading)
+  - [Other handlers](#other-handlers)
+  - [Failover handlers](#failover-handlers)
+- [Logger interface](#logger-interface)
+- [Using with rollbar-agent](#using-with-rollbar-agent)
+- [Rails booting process](#rails-booting-process)
+- [Rails runner command](#rails-runner-command)
+- [Deploy Tracking with Capistrano](#deploy-tracking-with-capistrano)
+  - [Capistrano 3](#capistrano-3)
+  - [Capistrano 2](#capistrano-2)
+- [Counting specific gems as in-project code](#counting-specific-gems-as-in-project-code)
+- [Goalie](#goalie)
+- [Resque](#resque-1)
+- [SSL](#ssl)
+- [Using with Zeus](#using-with-zeus)
+- [Configuration options](#configuration-options)
+- [Backwards Compatibility](#backwards-compatibility)
+- [Known Issues](#known-issues)
+- [Supported Language/Framework Versions](#supported-languageframework-versions)
+- [Help / Support](#help--support)
+- [Contributing](#contributing)
+
+<!-- END doctoc generated TOC please keep comment here to allow auto update -->
+
 
 ## Getting Started
 
@@ -31,7 +88,7 @@ gem 'oj', '~> 2.12.14'
 
 and then `bundle install` again.
 
-### If using Rails
+### Rails
 
 Run the following command from your Rails root:
 
@@ -62,7 +119,7 @@ $ heroku config:add ROLLBAR_ACCESS_TOKEN=POST_SERVER_ITEM_ACCESS_TOKEN
 That's all you need to use Rollbar with Rails.
 
 
-### If using Rack
+### Rack
 
 Initialize Rollbar with your access token somewhere during startup:
 
@@ -99,7 +156,7 @@ class MyApp < Sinatra::Base
 end
 ```
 
-### If using Plain Ruby
+### Plain Ruby
 
 Rollbar isn't dependent on Rack or Rails for most of its functionality. In a regular script, assuming you've
 installed the rollbar gem:
@@ -561,7 +618,7 @@ end
 
 If you need to customize the reporting write your own `rescue_from` handler instead of using the `Rollbar::ActiveJob` module.
 
-## Delayed::Job integration
+## Delayed::Job
 
 If `delayed_job` is defined, Rollbar will automatically install a plugin that reports any uncaught exceptions that occur in jobs.
 
@@ -590,7 +647,7 @@ Only versions >= 3.0 of delayed_job are supported.
 
 By default, all messages are reported synchronously. You can enable asynchronous reporting with [girl_friday](https://github.com/mperham/girl_friday), [sucker_punch](https://github.com/brandonhilkert/sucker_punch), [Sidekiq](https://github.com/mperham/sidekiq), [Resque](https://github.com/resque/resque), [DelayedJob](https://github.com/collectiveidea/delayed_job) or using threading.
 
-### Using girl_friday
+### girl_friday
 
 Add the following in ```config/initializers/rollbar.rb```:
 
@@ -600,7 +657,7 @@ config.use_async = true
 
 Asynchronous reporting falls back to Threading if girl_friday is not installed.
 
-### Using sucker_punch
+### sucker_punch
 
 Add the following in ```config/initializers/rollbar.rb```:
 
@@ -608,7 +665,7 @@ Add the following in ```config/initializers/rollbar.rb```:
 config.use_sucker_punch
 ```
 
-### Using Sidekiq
+### Sidekiq
 
 Add the following in ```config/initializers/rollbar.rb```:
 
@@ -641,7 +698,7 @@ For every errored job a new report will be sent to Rollbar API, also for errored
 config.sidekiq_threshold = 3 # Start reporting from 3 retries jobs
 ```
 
-### Using Resque
+### Resque
 
 Add the following in ```config/initializers/rollbar.rb```:
 
@@ -661,7 +718,7 @@ Now you can just start a new Resque worker processing jobs in that queue:
 $ QUEUE=my_queue bundle exec resque:work
 ```
 
-### Using DelayedJob
+### DelayedJob
 
 Add the following in ```config/initializers/rollbar.rb```:
 
@@ -669,7 +726,7 @@ Add the following in ```config/initializers/rollbar.rb```:
 config.use_delayed_job
 ```
 
-### Using threading
+### Threading
 
 Add the following in ```config/initializers/rollbar.rb```:
 
@@ -677,7 +734,7 @@ Add the following in ```config/initializers/rollbar.rb```:
 config.use_thread
 ```
 
-### Using another handler
+### Other handlers
 
 You can supply your own handler using ```config.async_handler```. The object to set for `async_handler` should respond to `#call` and receive the payload. The handler should schedule the payload for later processing (i.e. with a delayed_job, in a resque queue, etc.) and should itself return immediately. For example:
 
@@ -690,7 +747,7 @@ config.async_handler = Proc.new { |payload|
 
 Make sure you pass ```payload``` to ```Rollbar.process_from_async_handler``` in your own implementation.
 
-## Failover handlers
+### Failover handlers
 
 If you are using `async_handler` to process asynchronous the error it's possible that the handler fails before it calls `Rollbar.process_payload`. For example, for the Resque handler, the Redis connection could fail so the job is finally not processed.
 
@@ -831,12 +888,12 @@ Rollbar.configure do |config |
 end
 ```
 
-## Using with Goalie
+## Goalie
 
 If you're using [Goalie](https://github.com/obvio171/goalie) for custom error pages, you may need to explicitly add ```require 'goalie'``` to ```config/application.rb``` (in addition to ```require 'goalie/rails'```) so that the monkeypatch will work. (This will be obvious if it is needed because your app won't start up: you'll see a cryptic error message about ```Goalie::CustomErrorPages.render_exception``` not being defined.)
 
 
-## Using with Resque
+## Resque
 
 Check out [resque-rollbar](https://github.com/dimko/resque-rollbar) for using Rollbar as a failure backend for Resque.
 

data/docs/configuration.md

@@ -180,12 +180,22 @@ Rollbar load the traces before sending them.
 Set to `false` to skip automatic bundling of job metadata like queue, job class
 name, and job options.
 
+### open_timeout
+
+**Default** `3`
+
 ### request_timeout
 
 **Default** `3`
 
 Set the request timeout for sending POST data to Rollbar.
 
+### net_retries
+
+**Default** `3`
+
+Sets the number of retries cause timeouts on the POST request.
+
 ### root
 
 Set the server root, all stack frames outside that root are considered

data/gemfiles/rails30.gemfile

@@ -40,4 +40,6 @@ if Gem::Version.new(RUBY_VERSION) < Gem::Version.new('2.0')
   gem 'mime-types', '< 3.0'
 end
 
+gem 'webmock', :require => false
+
 gemspec :path => '../'

data/gemfiles/rails31.gemfile

@@ -38,4 +38,6 @@ if Gem::Version.new(RUBY_VERSION) < Gem::Version.new('2.0')
   gem 'mime-types', '< 3.0'
 end
 
+gem 'webmock', :require => false
+
 gemspec :path => "../"

data/gemfiles/rails32.gemfile

@@ -40,4 +40,6 @@ if Gem::Version.new(RUBY_VERSION) < Gem::Version.new('2.0')
   gem 'mime-types', '< 3.0'
 end
 
+gem 'webmock', :require => false
+
 gemspec :path => "../"

data/gemfiles/rails40.gemfile

@@ -40,4 +40,6 @@ if Gem::Version.new(RUBY_VERSION) < Gem::Version.new('2.0')
   gem 'mime-types', '< 3.0'
 end
 
+gem 'webmock', :require => false
+
 gemspec :path => "../"

data/gemfiles/rails41.gemfile

@@ -38,4 +38,6 @@ if Gem::Version.new(RUBY_VERSION) < Gem::Version.new('2.0')
   gem 'mime-types', '< 3.0'
 end
 
+gem 'webmock', :require => false
+
 gemspec :path => "../"

data/gemfiles/rails42.gemfile

@@ -38,4 +38,6 @@ if Gem::Version.new(RUBY_VERSION) < Gem::Version.new('2.0')
   gem 'mime-types', '< 3.0'
 end
 
+gem 'webmock', :require => false
+
 gemspec :path => "../"

data/gemfiles/rails50.gemfile

@@ -44,4 +44,6 @@ if Gem::Version.new(RUBY_VERSION) < Gem::Version.new('2.0')
   gem 'mime-types', '< 3.0'
 end
 
+gem 'webmock', :require => false
+
 gemspec :path => '../'

data/gemfiles/ruby_1_8_and_1_9_2.gemfile

@@ -0,0 +1,43 @@
+require 'rubygems/version'
+
+source 'https://rubygems.org'
+
+is_jruby = defined?(JRUBY_VERSION) || (defined?(RUBY_ENGINE) && 'jruby' == RUBY_ENGINE)
+
+gem 'sqlite3', :platform => [:ruby, :mswin, :mingw]
+gem 'jruby-openssl', :platform => :jruby
+gem 'activerecord-jdbcsqlite3-adapter', :platform => :jruby
+gem 'appraisal', '= 1.0.2'
+gem 'rubysl', '~> 2.0', :platform => :rbx
+gem 'racc', :platform => :rbx
+gem 'minitest', :platform => :rbx
+gem 'rubysl-test-unit', :platform => :rbx
+gem 'rubinius-developer_tools', :platform => :rbx
+gem 'rails', '3.0.20'
+gem 'hitimes', '< 1.2.2'
+gem 'rake', '< 11'
+gem 'rspec-rails', '>= 2.14.0'
+gem 'celluloid', '< 0.17.0' if RUBY_VERSION == '1.9.2'
+
+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')
+  gem 'sucker_punch', '~> 1.0'
+elsif RUBY_VERSION.start_with?('2')
+  gem 'sucker_punch', '~> 2.0'
+end
+
+gem 'sinatra'
+gem 'resque'
+gem 'delayed_job', :require => false
+gem 'redis'
+gem 'database_cleaner', '~> 1.0.0'
+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
+
+gemspec :path => '../'

data/lib/rollbar.rb

@@ -1,3 +1,4 @@
+require 'net/protocol'
 require 'net/https'
 require 'socket'
 require 'thread'
@@ -10,23 +11,25 @@ rescue LoadError
 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/railtie' if defined?(Rails::VERSION) && Rails::VERSION::MAJOR >= 3
 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'
 
 module Rollbar
   PUBLIC_NOTIFIER_METHODS = %w(debug info warn warning error critical log logger
-                               process_payload process_from_async_handler scope send_failsafe log_info log_debug
+                               process_item process_from_async_handler scope send_failsafe log_info log_debug
                                log_warning log_error silenced)
 
   class Notifier
@@ -175,20 +178,20 @@ module Rollbar
       log('critical', *args)
     end
 
-    def process_payload(payload)
+    def process_item(item)
       if configuration.write_to_file
         if configuration.use_async
           @file_semaphore.synchronize {
-            write_payload(payload)
+            write_item(item)
           }
         else
-          write_payload(payload)
+          write_item(item)
         end
       else
-        send_payload(payload)
+        send_item(item)
       end
     rescue => e
-      log_error("[Rollbar] Error processing the payload: #{e.class}, #{e.message}. Payload: #{payload.inspect}")
+      log_error("[Rollbar] Error processing the item: #{e.class}, #{e.message}. Item: #{item.payload.inspect}")
       raise e
     end
 
@@ -216,9 +219,13 @@ module Rollbar
     # 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)
+
       Rollbar.silenced do
         begin
-          process_payload(payload)
+          process_item(item)
         rescue => e
           report_internal_error(e)
 
@@ -227,13 +234,41 @@ module Rollbar
       end
     end
 
-    def custom_data
-      data = configuration.custom_data_method.call
-      Rollbar::Util.deep_copy(data)
-    rescue => e
-      return {} if configuration.safely?
+    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
+      }
 
-      report_custom_data_error(e)
+      failsafe_payload = {
+        'access_token' => configuration.access_token,
+        'data' => failsafe_data
+      }
+
+      begin
+        schedule_item(Item.build_with(failsafe_payload))
+      rescue => e
+        log_error "[Rollbar] Error sending failsafe : #{e}"
+      end
+
+      failsafe_payload
     end
 
     private
@@ -309,22 +344,19 @@ module Rollbar
 
     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."
+        log_error '[Rollbar] Tried to send a report with no message, exception or extra data.'
+
         return 'error'
       end
 
-      payload = build_payload(level, message, exception, extra)
-      data = payload['data']
+      item = build_item(level, message, exception, extra)
 
-      if data[:person]
-        person_id = data[:person][configuration.person_id_method.to_sym]
-        return 'ignored' if configuration.ignored_person_ids.include?(person_id)
-      end
+      return 'ignored' if item.ignored?
 
-      schedule_payload(payload)
+      schedule_item(item)
 
+      data = item['data']
       log_instance_link(data)
-
       Rollbar.last_report = data
 
       data
@@ -337,21 +369,21 @@ module Rollbar
       log_error "[Rollbar] Reporting internal error encountered while sending data to Rollbar."
 
       begin
-        payload = build_payload('error', nil, exception, {:internal => true})
+        item = build_item('error', nil, exception, {:internal => true})
       rescue => e
-        send_failsafe("build_payload in exception_data", e)
+        send_failsafe("build_item in exception_data", e)
         return
       end
 
       begin
-        process_payload(payload)
+        process_item(item)
       rescue => e
-        send_failsafe("error in process_payload", e)
+        send_failsafe("error in process_item", e)
         return
       end
 
       begin
-        log_instance_link(payload['data'])
+        log_instance_link(item['data'])
       rescue => e
         send_failsafe("error logging instance link", e)
         return
@@ -360,212 +392,31 @@ module Rollbar
 
     ## Payload building functions
 
-    def build_payload(level, message, exception, extra)
-      environment = configuration.environment
-      environment = 'unspecified' if environment.nil? || environment.empty?
-
-      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)
-      Rollbar::Util.deep_merge(data, scope_object)
-
-      # Our API doesn't allow null context values, so just delete
-      # the key if value is nil.
-      data.delete(:context) unless data[:context]
-
-      payload = {
-        'access_token' => configuration.access_token,
-        'data' => data
-      }
-
-      enforce_valid_utf8(payload)
-
-      call_transform(:level => level,
-                     :exception => exception,
-                     :message => message,
-                     :extra => extra,
-                     :payload => payload)
-
-      payload
-    end
-
-    def call_transform(options)
+    def build_item(level, message, exception, extra)
       options = {
-        :level => options[:level],
+        :level => level,
+        :message => message,
+        :exception => exception,
+        :extra => extra,
+        :configuration => configuration,
+        :logger => logger,
         :scope => scope_object,
-        :exception => options[:exception],
-        :message => options[:message],
-        :extra => options[:extra],
-        :payload => options[:payload]
-      }
-      handlers = configuration.transform
-
-      handlers.each do |handler|
-        begin
-          handler.call(options)
-        rescue => e
-          log_error("[Rollbar] Error calling the `transform` hook: #{e}")
-
-          break
-        end
-      end
-    end
-
-    def build_payload_body(message, exception, extra)
-      extra = Rollbar::Util.deep_merge(custom_data, extra || {}) if custom_data_method?
-
-      if exception
-        build_payload_body_exception(message, exception, extra)
-      else
-        build_payload_body_message(message, extra)
-      end
-    end
-
-    def custom_data_method?
-      !!configuration.custom_data_method
-    end
-
-    def report_custom_data_error(e)
-      data = safely.error(e)
-
-      return {} unless data.is_a?(Hash) && data[:uuid]
-
-      uuid_url = uuid_rollbar_url(data)
-
-      { :_error_in_custom_data_method => uuid_url }
-    end
-
-    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)
-      frames = exception_backtrace(exception).map do |frame|
-        # parse the line
-        match = frame.match(/(.*):(\d+)(?::in `([^']+)')?/)
-
-        if match
-          { :filename => match[1], :lineno => match[2].to_i, :method => match[3] }
-        else
-          { :filename => "<unknown>", :lineno => 0, :method => frame }
-        end
-      end
-
-        # reverse so that the order is as rollbar expects
-      frames.reverse!
-
-      {
-        :frames => frames,
-        :exception => {
-          :class => exception.class.name,
-          :message => exception.message
-        }
-      }
-    end
-
-    # Returns the backtrace to be sent to our API. There are 3 options:
-    #
-    # 1. The exception received has a backtrace, then that backtrace is returned.
-    # 2. configuration.populate_empty_backtraces is disabled, we return [] here
-    # 3. The user has configuration.populate_empty_backtraces is enabled, then:
-    #
-    # We want to send the caller as backtrace, but the first lines of that array
-    # are those from the user's Rollbar.error line until this method. We want
-    # to remove those lines.
-    def exception_backtrace(exception)
-      return exception.backtrace if exception.backtrace.respond_to?( :map )
-      return [] unless configuration.populate_empty_backtraces
-
-      caller_backtrace = caller
-      caller_backtrace.shift while caller_backtrace[0].include?(rollbar_lib_gem_dir)
-      caller_backtrace
-    end
-
-    def rollbar_lib_gem_dir
-      Gem::Specification.find_by_name('rollbar').gem_dir + '/lib'
-    end
-
-    def trace_chain(exception)
-      traces = [trace_data(exception)]
-      visited = [exception]
-
-      while exception.respond_to?(:cause) && (cause = exception.cause) && cause.is_a?(Exception) && !visited.include?(cause)
-        traces << trace_data(cause)
-        visited << cause
-        exception = cause
-      end
-
-      traces
-    end
-
-    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
+        :notifier => self
       }
-      data[:root] = configuration.root.to_s if configuration.root
-      data[:branch] = configuration.branch if configuration.branch
-      data[:pid] = Process.pid
 
-      data
-    end
+      item = Item.new(options)
+      item.build
 
-    def enforce_valid_utf8(payload)
-      normalizer = lambda { |object| Encoding.encode(object) }
-
-      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)
+      item
     end
 
     ## Delivery functions
 
-    def send_payload_using_eventmachine(payload)
-      body = dump_payload(payload)
-      headers = { 'X-Rollbar-Access-Token' => payload['access_token'] }
+    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
@@ -583,19 +434,25 @@ module Rollbar
       end
     end
 
-    def send_payload(payload)
-      log_info '[Rollbar] Sending payload'
-      payload = Rollbar::JSON.load(payload) if payload.is_a?(String)
+    def send_item(item)
+      log_info '[Rollbar] Sending item'
 
       if configuration.use_eventmachine
-        send_payload_using_eventmachine(payload)
+        send_item_using_eventmachine(item)
         return
       end
 
-      body = dump_payload(payload)
+      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'
@@ -606,10 +463,34 @@ module Rollbar
       end
 
       request = Net::HTTP::Post.new(uri.request_uri)
+
       request.body = body
-      request.add_field('X-Rollbar-Access-Token', payload['access_token'])
-      response = http.request(request)
+      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
@@ -626,20 +507,21 @@ module Rollbar
       end
     end
 
-    def write_payload(payload)
+    def write_item(item)
       if configuration.use_async
         @file_semaphore.synchronize {
-          do_write_payload(payload)
+          do_write_item(item)
         }
       else
-        do_write_payload(payload)
+        do_write_item(item)
       end
     end
 
-    def do_write_payload(payload)
-      log_info '[Rollbar] Writing payload to file'
+    def do_write_item(item)
+      log_info '[Rollbar] Writing item to file'
 
-      body = dump_payload(payload)
+      body = item.dump
+      return unless body
 
       begin
         unless @file
@@ -654,43 +536,6 @@ module Rollbar
       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
-        schedule_payload(failsafe_payload)
-      rescue => e
-        log_error "[Rollbar] Error sending failsafe : #{e}"
-      end
-
-      failsafe_payload
-    end
-
     def failsafe_reason(message, exception)
       body = ''
 
@@ -721,15 +566,15 @@ module Rollbar
       "Failsafe from rollbar-gem. #{reason}"
     end
 
-    def schedule_payload(payload)
-      return if payload.nil?
+    def schedule_item(item)
+      return unless item
 
-      log_info '[Rollbar] Scheduling payload'
+      log_info '[Rollbar] Scheduling item'
 
       if configuration.use_async
-        process_async_payload(payload)
+        process_async_item(item)
       else
-        process_payload(payload)
+        process_item(item)
       end
     end
 
@@ -739,49 +584,34 @@ module Rollbar
       Rollbar::Delay::Thread
     end
 
-    def process_async_payload(payload)
+    def process_async_item(item)
       configuration.async_handler ||= default_async_handler
-      configuration.async_handler.call(payload)
+      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(payload)
+      async_failover(item)
     end
 
-    def async_failover(payload)
+    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(payload)
+          handler.call(item.payload)
         rescue
           next unless handler == failover_handlers.last
 
-          log_error "[Rollbar] All failover handlers failed while processing payload: #{Rollbar::JSON.dump(payload)}"
+          log_error "[Rollbar] All failover handlers failed while processing item: #{Rollbar::JSON.dump(item.payload)}"
         end
       end
     end
 
-    def dump_payload(payload)
-      # Ensure all keys are strings since we can receive the payload inline or
-      # from an async handler job, which can be serialized.
-      stringified_payload = Rollbar::Util::Hash.deep_stringify_keys(payload)
-      result = Truncation.truncate(stringified_payload)
-      return result unless Truncation.truncate?(result)
-
-      original_size = Rollbar::JSON.dump(payload).bytesize
-      final_size = result.bytesize
-      send_failsafe("Could not send payload due to it being too large after truncating attempts. Original size: #{original_size} Final size: #{final_size}", nil)
-      log_error "[Rollbar] Payload too large to be sent: #{Rollbar::JSON.dump(payload)}"
-
-      nil
-    end
-
     ## Logging
     %w(debug info warn error).each do |level|
       define_method(:"log_#{level}") do |message|
@@ -793,15 +623,11 @@ module Rollbar
 
     def log_instance_link(data)
       if data[:uuid]
-        uuid_url = uuid_rollbar_url(data)
+        uuid_url = Util.uuid_rollbar_url(data, configuration)
         log_info "[Rollbar] Details: #{uuid_url} (only available if report was successful)"
       end
     end
 
-    def uuid_rollbar_url(data)
-      "#{configuration.web_base}/instance/uuid?uuid=#{data[:uuid]}"
-    end
-
     def logger
       @logger ||= LoggerProxy.new(configuration.logger)
     end
@@ -812,6 +638,8 @@ module Rollbar
 
     def_delegators :notifier, *PUBLIC_NOTIFIER_METHODS
 
+    attr_writer :plugins
+
     # Similar to configure below, but used only internally within the gem
     # to configure it without initializing any of the third party hooks
     def preconfigure
@@ -826,7 +654,7 @@ module Rollbar
 
       yield(configuration)
 
-      prepare
+      plugins.load!
       reset_notifier!
     end
 
@@ -854,52 +682,8 @@ module Rollbar
       configuration.safely?
     end
 
-    def prepare
-      prepare_js
-      require_hooks
-      require_core_extensions
-    end
-
-    def prepare_js
-      ::Rollbar::Js.prepare if configuration.js_enabled
-    end
-
-    def require_hooks
-      return if configuration.disable_monkey_patch
-      wrap_delayed_worker
-
-      if defined?(ActiveRecord)
-        require 'active_record/version'
-        require 'rollbar/active_record_extension' if ActiveRecord::VERSION::MAJOR >= 3
-      end
-
-      require 'rollbar/sidekiq' if defined?(Sidekiq)
-      require 'rollbar/active_job' if defined?(ActiveJob)
-      require 'rollbar/goalie' if defined?(Goalie)
-      require 'rollbar/rack' if defined?(Rack) unless configuration.disable_rack_monkey_patch
-      require 'rollbar/rake' if defined?(Rake)
-    end
-
-    def require_core_extensions
-      # This monkey patch is always needed in order
-      # to use Rollbar.scoped
-      require 'rollbar/core_ext/thread'
-
-      return if configuration.disable_core_monkey_patch
-
-      # Needed to avoid active_support (< 4.1.0) bug serializing JSONs
-      require 'rollbar/core_ext/basic_socket' if monkey_patch_socket?
-    end
-
-    def monkey_patch_socket?
-      defined?(ActiveSupport::VERSION::STRING)
-    end
-
-    def wrap_delayed_worker
-      return unless defined?(Delayed) && defined?(Delayed::Worker) && configuration.delayed_job_enabled
-
-      require 'rollbar/delayed_job'
-      Rollbar::Delayed.wrap_worker
+    def plugins
+      @plugins ||= Rollbar::Plugins.new
     end
 
     def notifier
@@ -984,3 +768,5 @@ module Rollbar
     end
   end
 end
+
+Rollbar.plugins.require_all