rollbar 0.8.0

data/.gitignore

@@ -0,0 +1,20 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+log/
+lib/bundler/man
+vendor/bundle
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+*.swp

data/.travis.yml

@@ -0,0 +1,17 @@
+language: ruby
+rvm:
+  - 1.8.7
+  - 1.9.3
+  - 1.9.2
+  - ruby-head
+  - jruby-18mode
+  - jruby-19mode
+  - jruby-head
+  - rbx-18mode
+  - rbx-19mode
+matrix:
+  allow_failures:
+    - rvm: ruby-head
+    - rvm: rbx-18mode
+    - rvm: jruby-18mode
+    - rvm: jruby-19mode

data/CHANGELOG.md

@@ -0,0 +1,90 @@
+# Change Log
+
+**0.8.0**
+- Rename to rollbar
+
+**0.7.1**
+- Fix ratchetio:test rake task when project base controller is not called ApplicationController
+
+**0.7.0**
+- Exceptions in Rake tasks are now automatically reported.
+
+**0.6.4**
+- Bump multi_json dependency version to 1.6.0
+
+**0.6.3**
+- Bump multi_json dependency version to 1.5.1
+
+**0.6.2**
+- Added EventMachine support
+
+**0.6.1**
+- Added a log message containing a link to the instance. Copy-paste the link into your browser to view its details in Ratchet.
+- Ratchetio.report_message now returns 'ignored' or 'error' instead of nil when a message is not reported for one of those reasons, for consistency with Ratchetio.report_exception.
+
+**0.6.0**
+- POSSIBLE BREAKING CHANGE: Ratchetio.report_exception now returns 'ignored', 'disabled', or 'error' instead of nil when the exception is not reported for one of those reasons. It still returns the payload upon success.
+- Request data is now parsed from the rack environment instead of from within the controller, addressing issue #10.
+- Add Sidekiq middleware for catching workers' exceptions
+- Replaced activesupport dependency with multi_json
+
+**0.5.5**
+- Added activesupport dependency for use without Rails 
+
+**0.5.4**
+- Added new default scrub params
+
+**0.5.3**
+- Add `Ratchetio.silenced`; which allows disabling reporting for a given block. See README for usage.
+
+**0.5.2**
+- Fix compat issue with delayed_job below version 3. Exceptions raised by delayed_job below version 3 will not be automatically caught; upgrade to v3 or catch and report by hand. 
+
+**0.5.1**
+- Save the exception uuid in `env['ratchetio.exception_uuid']` for display in user-facing error pages.
+
+**0.5.0**
+- Add support to report exceptions raised in delayed_job.
+
+**0.4.11**
+- Allow exceptions with no backtrace (e.g. StandardError subclasses)
+
+**0.4.10**
+- Fix compatability issue with ruby 1.8
+
+**0.4.9**
+- Start including a UUID in reported exceptions
+- Fix issue with scrub_fields, and add `:password_confirmation` to the default list
+
+**0.4.8**
+- Add ability to send reports asynchronously, using girl_friday or Threading by default.
+- Add ability to save reports to a file (for use with ratchet-agent) instead of sending across to Ratchet servers.
+
+**0.4.7**
+- Sensitive params now scrubbed out of requests. Param name list is customizable via the `scrub_fields` config option.
+
+**0.4.6**
+- Add support to play nicely with Goalie.
+
+**0.4.5**
+- Add `default_logger` config option. It should be a lambda that will return the logger to use if no other logger is configured (i.e. no logger is set by the Railtie hook). Default: `lambda { Logger.new(STDERR) }`
+
+**0.4.4**
+- Add `enabled` runtime config flag. When `false`, no data (messages or exceptions) will be reported.
+
+**0.4.3**
+- Add RSpec test suite. A few minor code changes.
+
+**0.4.2**
+- Add "ignore" filter level to completely ignore exceptions by class.
+
+**0.4.1**
+- Recursively filter files out of the params hash. Thanks to [trisweb](https://github.com/trisweb) for the pull request.
+
+**0.4.0**
+ 
+- Breaking change to make the "person" more configurable. If you were previously relying on your `current_member` method being called to return the person object, you will need to add the following line to `config/initializers/ratchetio.rb`:
+    
+    config.person_method = "current_member"
+
+- Person id, username, and email method names are now configurable -- see README for details.

data/Gemfile

@@ -0,0 +1,8 @@
+source 'https://rubygems.org'
+
+gemspec
+
+gem 'sqlite3',                          :platform => [:ruby, :mswin, :mingw]
+gem 'jruby-openssl',                    :platform => :jruby
+gem 'activerecord-jdbcsqlite3-adapter', :platform => :jruby
+gem 'girl_friday'

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Rollbar, Inc.
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,165 @@
+# Rollbar [![Build Status](https://secure.travis-ci.org/rollbar/rollbar-gem.png?branch=master)](https://travis-ci.org/rollbar/rollbar-gem)
+
+Ruby gem for Rollbar, for reporting exceptions in Rails 3 to Rollbar. Requires a Rollbar account (you can sign up for free).
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'rollbar'
+
+And then execute:
+
+    $ bundle install
+
+Or install it yourself as:
+
+    $ gem install rollbar
+
+Then, run the following command from your rails root:
+
+    $ rails generate rollbar YOUR_ROLLBAR_PROJECT_ACCESS_TOKEN
+
+That will create the file `config/initializers/rollbar.rb`, which holds the configuration values (currently just your access token) and is all you need to use Rollbar with Rails.
+
+To confirm that it worked, run:
+
+    $ 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.
+
+## Manually reporting exceptions and messages
+
+To report a caught exception to Rollbar, simply call `Rollbar.report_exception`:
+
+```ruby
+begin
+  foo = bar
+rescue Exception => e
+  Rollbar.report_exception(e)
+end
+```
+
+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:
+
+```ruby
+begin
+  foo = bar
+rescue Exception => e
+  Rollbar.report_exception(e, rollbar_request_data, rollbar_person_data)
+end
+```
+
+You can also log individual messages:
+
+```ruby
+# logs at the 'warning' level. all levels: debug, info, warning, error, critical
+Rollbar.report_message("Unexpected input", "warning")
+
+# default level is "info"
+Rollbar.report_message("Login successful")
+
+# can also include additional data as a hash in the final param. :body is reserved.
+Rollbar.report_message("Login successful", "info", :user => @user)
+```
+
+
+## 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"
+```
+
+
+## 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:
+
+- ActiveRecord::RecordNotFound
+- AbstractController::ActionNotFound
+- ActionController::RoutingError
+
+If you'd like to customize this list, see the example code in `config/initializers/rollbar.rb`. Supported levels: "critical", "error", "warning", "info", "debug", "ignore". Set to "ignore" to cause the exception not to be reported at all.
+
+
+## Silencing exceptions at runtime
+
+If you just want to disable exception reporting for a single block, use `Rollbar.silenced`:
+
+```ruby
+Rollbar.silenced {
+  foo = bar  # will not be reported
+}
+```
+
+
+## Asynchronous reporting
+
+By default, all messages are reported synchronously. You can enable asynchronous reporting by adding the following in `config/initializers/rollbar.rb`:
+
+```ruby
+  config.use_async = true
+```
+
+Rollbar uses [girl_friday](https://github.com/mperham/girl_friday) to handle asynchronous reporting when installed, and falls back to Threading if girl_friday is not installed.
+
+You can supply your own handler using `config.async_handler`. 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:
+
+```ruby
+  config.async_handler = Proc.new { |payload|
+    Thread.new { Rollbar.process_payload(payload) }
+  }
+```
+
+Make sure you pass `payload` to `Rollbar.process_payload` in your own implementation.
+
+
+## Using with rollbar-agent
+
+For even more asynchrony, you can configure the gem to write to a file instead of sending the payload to Rollbar servers directly. [rollbar-agent](https://github.com/rollbar/rollbar-agent) can then be hooked up to this file to actually send the payload across. To enable, add the following in `config/initializers/rollbar.rb`:
+
+```ruby
+  config.write_to_file = true
+  # optional, defaults to "#{AppName}.rollbar"
+  config.filepath = '/path/to/file.rollbar' #should end in '.rollbar' for use with rollbar-agent
+```
+
+For this to work, you'll also need to set up rollbar-agent--see its docs for details.
+
+
+## Using with 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
+
+Check out [resque-ratchetio](https://github.com/CrowdFlower/resque-ratchetio) for using Rollbar as a failure backend for Resque.
+
+
+## Help / Support
+
+If you run into any issues, please email us at `support@rollbar.com`
+
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Added some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request
+
+We're using RSpec for testing. Run the test suite with `rake spec`. Tests for pull requests are appreciated but not required. (If you don't include a test, we'll write one before merging.)

data/Rakefile

@@ -0,0 +1,14 @@
+#!/usr/bin/env rake
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+namespace :dummy do
+  load 'spec/dummyapp/Rakefile'
+end
+
+desc 'Run specs'
+task :default => ['dummy:db:setup'] do
+  Rake::Task[:spec].invoke
+end

data/THANKS

@@ -0,0 +1,10 @@
+Huge thanks to the following contributors (by github username). For the most up-to-date list, see https://github.com/rollbar/rollbar-gem/graphs/contributors
+
+arr-ee
+JoshuaOSHickman
+kavu
+magnolia-fan
+mipearson
+trisweb
+tysontate
+wbond

data/lib/generators/rollbar/rollbar_generator.rb

@@ -0,0 +1,53 @@
+require 'rails/generators'
+require 'rails/generators/named_base'
+
+module Rollbar
+  module Generators
+    class RollbarGenerator < ::Rails::Generators::Base
+      argument :access_token, :type => :string, :banner => 'access_token'
+
+      source_root File.expand_path(File.join(File.dirname(__FILE__), 'templates'))
+
+      def create_initializer
+        puts "creating initializer..."
+        if access_token_configured?
+          puts "It looks like you've already configured Rollbar."
+          puts "To re-create the config file, remove it first: config/initializers/rollbar.rb"
+          exit
+        end
+
+        puts "access token: " << access_token
+
+        template 'initializer.rb', 'config/initializers/rollbar.rb',
+          :assigns => { :access_token => access_token_expr }
+
+        # TODO run rake test task
+      end
+
+      #def add_options!(opt)
+      #  opt.on('-a', '--access-token=token', String, "Your Rollbar project access token") { |v| options[:access_token] = v }
+      #end
+#
+#      def manifest
+#        if !access_token_configured? && !options[:access_token]
+#          puts "access_token is required. Pass --access-token=YOUR_ACCESS_TOKEN"
+#          exit
+#        end
+#        
+#        record do |m|
+#          m.template 'initializer.rb', 'config/initializers/rollbar.rb',
+#            :assigns => { :access_token => access_token_expr }
+#          # TODO run rake test task
+#        end
+#      end
+
+      def access_token_expr
+        "'#{access_token}'"
+      end
+
+      def access_token_configured?
+        File.exists?('config/initializers/rollbar.rb')
+      end
+    end
+  end
+end

data/lib/generators/rollbar/templates/initializer.rb

@@ -0,0 +1,28 @@
+require 'rollbar/rails'
+Rollbar.configure do |config|
+  config.access_token = <%= access_token_expr %>
+
+  # By default, Rollbar will try to call the `current_user` controller method
+  # to fetch the logged-in user object, and then call that object's `id`,
+  # `username`, and `email` methods to fetch those properties. To customize:
+  # config.person_method = "my_current_user"
+  # config.person_id_method = "my_id"
+  # config.person_username_method = "my_username"
+  # config.person_email_method = "my_email"
+
+  # Add exception class names to the exception_level_filters hash to
+  # change the level that exception is reported at. Note that if an exception
+  # has already been reported and logged the level will need to be changed
+  # via the rollbar interface.
+  # Valid levels: 'critical', 'error', 'warning', 'info', 'debug', 'ignore'
+  # 'ignore' will cause the exception to not be reported at all.
+  # config.exception_level_filters.merge!('MyCriticalException' => 'critical')
+  
+  # Enable asynchronous reporting (uses girl_friday or Threading if girl_friday
+  # is not installed)
+  # config.use_async = true
+  # Supply your own async handler:
+  # config.async_handler = Proc.new { |payload|
+  #  Thread.new { Rollbar.process_payload(payload) }
+  # }
+end

data/lib/rollbar.rb

@@ -0,0 +1,358 @@
+require 'net/https'
+require 'securerandom' if defined?(SecureRandom)
+require 'socket'
+require 'thread'
+require 'uri'
+
+require "girl_friday" if defined?(GirlFriday)
+
+require 'rollbar/version'
+require 'rollbar/configuration'
+require 'rollbar/request_data_extractor'
+require 'rollbar/exception_reporter'
+
+require 'rollbar/delayed_job' if defined?(Delayed) && defined?(Delayed::Plugins)
+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/railtie' if defined?(Rails)
+
+module Rollbar
+  class << self
+    attr_writer :configuration
+    attr_reader :last_report
+
+    # 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
+    def configure
+      yield(configuration)
+    end
+
+    def reconfigure
+      @configuration = Configuration.new
+      yield(configuration)
+    end
+
+    # Returns the configuration object.
+    #
+    # @return [Rollbar::Configuration] The configuration object
+    def configuration
+      @configuration ||= Configuration.new
+    end
+
+    # Reports an exception to Rollbar. Returns the exception data hash.
+    #
+    # @example
+    #   begin
+    #     foo = bar
+    #   rescue => e
+    #     Rollbar.report_exception(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)
+      return 'disabled' unless configuration.enabled
+      return 'ignored' if ignored?(exception)
+
+      data = exception_data(exception, filtered_level(exception))
+      data[:request] = 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 => e
+      logger.error "[Rollbar] Error reporting exception to Rollbar: #{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)
+      payload = build_payload(data)
+      schedule_payload(payload)
+      log_instance_link(data)
+      data
+    rescue => e
+      logger.error "[Rollbar] Error reporting message to Rollbar: #{e}"
+      'error'
+    end
+
+    # 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
+      end
+    end
+
+    def process_payload(payload)
+      begin
+        if configuration.write_to_file
+          write_payload(payload)
+        else
+          send_payload(payload)
+        end
+      rescue => e
+        logger.error "[Rollbar] Error reporting message to Rollbar: #{e}"
+      end
+    end
+
+    private
+
+    def log_instance_link(data)
+      logger.info "[Rollbar] Details: #{configuration.web_base}/instance/uuid?uuid=#{data[:uuid]}"
+    end
+
+    def ignored?(exception)
+      if filtered_level(exception) == 'ignore'
+        return true
+      end
+
+      if exception.instance_variable_get(:@_rollbar_do_not_report)
+        return true
+      end
+
+      false
+    end
+
+    def filtered_level(exception)
+      configuration.exception_level_filters[exception.class.name]
+    end
+
+    def message_data(message, level, extra_data)
+      data = base_data(level)
+
+      data[:body] = {
+        :message => {
+          :body => message.to_s
+        }
+      }
+      data[:body][:message].merge!(extra_data)
+      data[:server] = server_data
+
+      data
+    end
+
+    def exception_data(exception, force_level = nil)
+      data = base_data
+
+      data[:level] = force_level if force_level
+
+      # parse backtrace
+      if exception.backtrace.respond_to?( :map )
+        frames = exception.backtrace.map { |frame|
+          # parse the line
+          match = frame.match(/(.*):(\d+)(?::in `([^']+)')?/)
+          { :filename => match[1], :lineno => match[2].to_i, :method => match[3] }
+        }
+        # reverse so that the order is as rollbar expects
+        frames.reverse!
+      else
+        frames = []
+      end
+
+      data[:body] = {
+        :trace => {
+          :frames => frames,
+          :exception => {
+            :class => exception.class.name,
+            :message => exception.message
+          }
+        }
+      }
+
+      data[:server] = server_data
+
+      data
+    end
+
+    def logger
+      # init if not set
+      unless configuration.logger
+        configuration.logger = configuration.default_logger.call
+      end
+      configuration.logger
+    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)
+      logger.info '[Rollbar] Writing payload to file'
+
+      begin
+        unless @file
+          @file = File.open(configuration.filepath, "a")
+        end
+
+        @file.puts payload
+        @file.flush
+        logger.info "[Rollbar] Success"
+      rescue IOError => e
+        logger.error "[Rollbar] Error opening/writing to file: #{e}"
+      end
+    end
+
+    def send_payload_using_eventmachine(payload)      
+      req = EventMachine::HttpRequest.new(configuration.endpoint).post(:body => payload)
+      req.callback do
+        if req.response_header.status == 200
+          logger.info '[Rollbar] Success'
+        else
+          logger.warn "[Rollbar] Got unexpected status code from Rollbar.io api: #{req.response_header.status}"
+          logger.info "[Rollbar] Response: #{req.response}"          
+        end
+      end
+      req.errback do
+        logger.warn "[Rollbar] Call to API failed, status code: #{req.response_header.status}"
+        logger.info "[Rollbar] Error's response: #{req.response}"    
+      end
+    end
+
+    def send_payload(payload)
+      logger.info '[Rollbar] Sending payload'
+      
+      if configuration.use_eventmachine
+        send_payload_using_eventmachine(payload)
+        return
+      end
+      uri = URI.parse(configuration.endpoint)
+      http = Net::HTTP.new(uri.host, uri.port)
+
+      if uri.scheme == 'https'
+        http.use_ssl = true
+        http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+      end
+
+      request = Net::HTTP::Post.new(uri.request_uri)
+      request.body = payload
+      response = http.request(request)
+
+      if response.code == '200'
+        logger.info '[Rollbar] Success'
+      else
+        logger.warn "[Rollbar] Got unexpected status code from Rollbar api: #{response.code}"
+        logger.info "[Rollbar] Response: #{response.body}"
+      end
+    end
+
+    def schedule_payload(payload)
+      logger.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
+
+    def build_payload(data)
+      payload = {
+        :access_token => configuration.access_token,
+        :data => data
+      }
+      MultiJson.dump(payload)
+    end
+
+    def base_data(level = 'error')
+      config = configuration
+      data = {
+        :timestamp => Time.now.to_i,
+        :environment => config.environment,
+        :level => level,
+        :language => 'ruby',
+        :framework => config.framework,
+        :notifier => {
+          :name => 'rollbar-gem',
+          :version => VERSION
+        }
+      }
+
+      if defined?(SecureRandom) and SecureRandom.respond_to?(:uuid)
+        data[:uuid] = SecureRandom.uuid
+      end
+
+      data
+    end
+
+    def server_data
+      config = configuration
+
+      data = {
+        :host => Socket.gethostname
+      }
+      data[:root] = config.root.to_s if config.root
+      data[:branch] = config.branch if config.branch
+
+      data
+    end
+
+    def default_async_handler(payload)
+      if defined?(GirlFriday)
+        unless @queue
+          @queue = GirlFriday::WorkQueue.new(nil, :size => 5) do |payload|
+            process_payload(payload)
+          end
+        end
+
+        @queue.push(payload)
+      else
+        logger.warn '[Rollbar] girl_friday not found to handle async call, falling back to Thread'
+        Thread.new { process_payload(payload) }
+      end
+    end
+  end
+end