rollbar 0.10.4 → 0.10.5

data/CHANGELOG.md

@@ -1,5 +1,8 @@
 # Change Log
 
+**0.10.5**
+- Add built-in support for Sidekiq as async handler
+
 **0.10.4**
 - Fix exception in the exception catcher when Rollbar is disabled
 

data/README.md

@@ -1,6 +1,8 @@
-# Rollbar [![Build Status](https://secure.travis-ci.org/rollbar/rollbar-gem.png?branch=master)](https://travis-ci.org/rollbar/rollbar-gem)
+# Rollbar notifier for Ruby [![Build Status](https://secure.travis-ci.org/rollbar/rollbar-gem.png?branch=master)](https://travis-ci.org/rollbar/rollbar-gem)
 
-Ruby gem for reporting exceptions, errors, and log messages to [Rollbar](https://rollbar.com). Requires a Rollbar account (you can [sign up for free](https://rollbar.com/signup)). Basic integration in a Rails 3 app should only take a few minutes.
+Ruby gem for reporting exceptions, errors, and log messages to [Rollbar](https://rollbar.com).
+
+<!-- Sub:[TOC] -->
 
 ## Installation
 
@@ -10,43 +12,57 @@ Add this line to your application's Gemfile:
 
 And then execute:
 
-    $ bundle install
+```bash
+$ bundle install
+```
 
 Or install it yourself as:
 
-    $ gem install rollbar
+```bash
+$ gem install rollbar
+```
 
 Then, run the following command from your rails root:
 
-    $ rails generate rollbar your-rollbar-post_server_item-token
+```bash
+$ rails generate rollbar POST_SERVER_ITEM_ACCESS_TOKEN
+```
 
-That will create the file `config/initializers/rollbar.rb`, which holds the configuration values (currently just your access token). Make sure you're using the `post_server_item` access token.
+That will create the file ```config/initializers/rollbar.rb```, which holds the configuration values (currently just your access token). Make sure you're using the ```post_server_item``` access token.
 
 If you want to store your access token outside of your repo, run the same command without arguments:
 
-    $ rails generate rollbar
+```bash
+$ rails generate rollbar
+```
 
-Then, create an environment variable `ROLLBAR_ACCESS_TOKEN` and set it to your server-side access token.
+Then, create an environment variable ```ROLLBAR_ACCESS_TOKEN``` and set it to your server-side access token.
 
-    $ export ROLLBAR_ACCESS_TOKEN=your-rollbar-post_server_item-token
+```bash
+$ export ROLLBAR_ACCESS_TOKEN=POST_SERVER_ITEM_ACCESS_TOKEN
+```
 
-or
-   
-    $ heroku config:add ROLLBAR_ACCESS_TOKEN=your-rollbar-post_server_item-token
+### For Heroku users
 
-if you are using Heroku.
+```bash
+$ heroku config:add ROLLBAR_ACCESS_TOKEN=POST_SERVER_ITEM_ACCESS_TOKEN
+```
 
 That's all you need to use Rollbar with Rails.
 
+## Test your installation
+
 To confirm that it worked, run:
 
-    $ rake rollbar:test
+```bash
+$ 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`:
+To report a caught exception to Rollbar, simply call ```Rollbar.report_exception```:
 
 ```ruby
 begin
@@ -79,55 +95,72 @@ Rollbar.report_message("Login successful")
 Rollbar.report_message("Login successful", "info", :user => @user)
 ```
 
+## Data sanitization (scrubbing)
 
-## Person tracking
+By default, the notifier will "scrub" the following fields from requests before sending to Rollbar
+
+- ```:passwd```
+- ```:password```
+- ```:password_confirmation```
+- ```:secret```
+- ```:confirm_password```
+- ```:password_confirmation```
+- ```:secret_token```
 
-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 a request contains one of these fields, the value will be replaced with a ```"*"``` before being sent.
 
-If the gem should call a controller method besides `current_user`, add the following in `config/initializers/rollbar.rb`:
+Additional fields can be scrubbed by updating ```Rollbar.configuration.scrub_fields```:
 
 ```ruby
-  config.person_method = "my_current_user"
+# scrub out the "user_password" field
+Rollbar.configuration.scrub_fields |= [:user_password]
 ```
 
-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`:
+## 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_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"
+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"
+```
 
 ## 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 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. 
 
-Add the following in `config/initializers/rollbar.rb`:
+Add the following in ```config/initializers/rollbar.rb```:
 
 ```ruby
-  config.custom_data_method = lambda {
-    { :some_key => :some_value, :complex_key => {:a => 1, :b => [2, 3, 4]} }
-  }
+config.custom_data_method = lambda {
+  { :some_key => :some_value, :complex_key => {:a => 1, :b => [2, 3, 4]} }
+}
 ```
 
 This data will appear in the Occurrences tab and on the Occurrence Detail pages in the Rollbar interface.
 
-
 ## 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
+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:
 
-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.
+- ```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`:
+If you just want to disable exception reporting for a single block, use ```Rollbar.silenced```:
 
 ```ruby
 Rollbar.silenced {
@@ -135,67 +168,104 @@ Rollbar.silenced {
 }
 ```
 
-
 ## Asynchronous reporting
 
-By default, all messages are reported synchronously. You can enable asynchronous reporting by adding the following in `config/initializers/rollbar.rb`:
+By default, all messages are reported synchronously. You can enable asynchronous reporting with [girl_friday](https://github.com/mperham/girl_friday) or [Sidekiq](https://github.com/mperham/sidekiq). 
+
+### Using girl_friday
+
+Add the following in ```config/initializers/rollbar.rb```:
 
 ```ruby
-  config.use_async = true
+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.
+Asynchronous reporting falls back to Threading if girl_friday is not installed.
+
+### Using Sidekiq
+
+Add the following in ```config/initializers/rollbar.rb```:
+
+```ruby
+config.use_sidekiq = true
+```
 
-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:
+You can also supply custom Sidekiq options:
 
 ```ruby
-  config.async_handler = Proc.new { |payload|
-    Thread.new { Rollbar.process_payload(payload) }
-  }
+config.use_sidekiq = { 'queue' => 'my_queue' }
 ```
 
-Make sure you pass `payload` to `Rollbar.process_payload` in your own implementation.
+Start the redis server:
+
+```bash
+$ redis-server
+```
+
+Start Sidekiq from the root directory of your Rails app and declare the name of your queue. Unless you've configured otherwise, the queue name is "rollbar":
+
+```bash
+$ bundle exec sidekiq -q rollbar
+```
 
+### Using another handler
+
+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`:
+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
+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.
 
-
 ## Deploy Tracking with Capistrano
 
-Add the following to `deploy.rb`:
+Add the following to ```deploy.rb```:
 
 ```ruby
 require 'rollbar/capistrano'
-set :rollbar_token, 'your-rollbar-project-access-token'
+set :rollbar_token, 'POST_SERVER_ITEM_ACCESS_TOKEN'
 ```
 
 Available options:
 
-- `rollbar_token` - the same project access token as you used for the `rails generate rollbar` command; find it in `config/initializers/rollbar.rb`. (It's repeated here for performance reasons, so the rails environment doesn't have to be initialized.)
-- `rollbar_env` - deploy environment name, `rails_env` by default
+  <dl>
+  <dt>rollbar_token</dt>
+  <dd>The same project access token as you used for the ```rails generate rollbar``` command; find it in ```config/initializers/rollbar.rb```. (It's repeated here for performance reasons, so the rails environment doesn't have to be initialized.)
+  </dd>
+  <dt>rollbar_env</dt>
+  <dd>Deploy environment name
+  
+Default: ```rails_env```
+
+  </dd>
+  </dl>
 
-For `capistrano/multistage`, try:
+For ```capistrano/multistage```, try:
 
 ```ruby
 set(:rollbar_env) { stage }
 ```
 
-
 ## Counting specific gems as in-project code
 
-In the Rollbar interface, stacktraces are shown with in-project code expanded and other code collapsed. Stack frames are counted as in-project if they occur in a file that is inside of the `configuration.root` (automatically set to `Rails.root` if you're using Rails). The collapsed sections can be expanded by clicking on them.
+In the Rollbar interface, stacktraces are shown with in-project code expanded and other code collapsed. Stack frames are counted as in-project if they occur in a file that is inside of the `configuration.root` (automatically set to ```Rails.root``` if you're using Rails). The collapsed sections can be expanded by clicking on them.
 
-If you want code from some specific gems to start expanded as well, you can configure this in `config/initializers/rollbar.rb`:
+If you want code from some specific gems to start expanded as well, you can configure this in ```config/initializers/rollbar.rb```:
 
 ```ruby
 Rollbar.configure do |config |
@@ -204,10 +274,9 @@ Rollbar.configure do |config |
 end
 ```
 
-
 ## 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.)
+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
@@ -217,20 +286,20 @@ Check out [resque-rollbar](https://github.com/CrowdFlower/resque-rollbar) for us
 
 ## Using with Zeus
 
-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. 
+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. 
 
 
 ## Help / Support
 
-If you run into any issues, please email us at `support@rollbar.com`
+If you run into any issues, please email us at [support@rollbar.com](mailto: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`)
+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.)
+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/THANKS.md

@@ -4,8 +4,10 @@ Huge thanks to the following contributors (by github username). For the most up-
 
 - [arr-ee](https://github.com/arr-ee)
 - [dimko](https://github.com/dimko)
+- [fabsays](https://github.com/fabsays)
 - [firstbanco](https://github.com/firstbanco)
 - [ixti](https://github.com/ixti)
+- [jeremyvdw](https://github.com/jeremyvdw)
 - [johnknott](https://github.com/johnknott)
 - [JoshuaOSHickman](https://github.com/JoshuaOSHickman)
 - [juggler](https://github.com/juggler)

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

@@ -36,4 +36,9 @@ Rollbar.configure do |config|
   # config.async_handler = Proc.new { |payload|
   #  Thread.new { Rollbar.process_payload(payload) }
   # }
+
+  # Enable delayed reporting (using Sidekiq)
+  # config.use_sidekiq = true
+  # You can supply custom Sidekiq options:
+  # config.use_sidekiq = { 'queue' => 'my_queue' }
 end

data/lib/rollbar/configuration.rb

@@ -21,6 +21,7 @@ module Rollbar
     attr_accessor :person_email_method
     attr_accessor :root
     attr_accessor :scrub_fields
+    attr_accessor :use_sidekiq
     attr_accessor :use_async
     attr_accessor :use_eventmachine
     attr_accessor :web_base
@@ -52,11 +53,20 @@ module Rollbar
       @scrub_fields = [:passwd, :password, :password_confirmation, :secret,
                        :confirm_password, :password_confirmation, :secret_token]
       @use_async = false
+      @use_sidekiq = false
       @use_eventmachine = false
       @web_base = DEFAULT_WEB_BASE
       @write_to_file = false
     end
     
+    def use_sidekiq=(value)
+      if value
+        require 'rollbar/delay/sidekiq' if defined?(Sidekiq)
+        @use_async      = true
+        @async_handler  = Rollbar::Delay::Sidekiq.method(:handle)
+      end
+    end
+
     def use_eventmachine=(value)
       require 'em-http-request' if value
       @use_eventmachine = value

data/lib/rollbar/delay/sidekiq.rb

@@ -0,0 +1,21 @@
+require 'sidekiq'
+
+module Rollbar
+  module Delay
+    class Sidekiq
+      OPTIONS = { 'queue' => 'rollbar', 'class' => self.name }.freeze
+
+      def self.handle(payload)
+        item = @use_sidekiq.is_a?(Hash) ? OPTIONS.merge(@use_sidekiq) : OPTIONS
+
+        ::Sidekiq::Client.push item.merge('args' => [payload])
+      end
+
+      include ::Sidekiq::Worker
+
+      def perform(*args)
+        Rollbar.process_payload(*args)
+      end
+    end
+  end
+end

data/lib/rollbar/version.rb

@@ -1,3 +1,3 @@
 module Rollbar
-  VERSION = "0.10.4"
+  VERSION = "0.10.5"
 end

data/spec/rollbar_spec.rb

@@ -290,6 +290,28 @@ describe Rollbar do
         config.async_handler = Rollbar.method(:default_async_handler)
       end
     end
+
+    it "should send the payload to sidekiq delayer" do
+      module Rollbar
+        module Delay
+          class Sidekiq
+          end
+        end
+      end
+
+      Rollbar::Delay::Sidekiq.should_receive(:handle).with(anything)
+
+      Rollbar.configure do |config|
+        config.use_sidekiq = { 'queue' => 'test_queue' }
+      end
+
+      Rollbar.report_exception(@exception)
+
+      Rollbar.configure do |config|
+        config.use_async = false
+        config.async_handler = Rollbar.method(:default_async_handler)
+      end
+    end
   end
 
   context 'message_data' do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rollbar
 version: !ruby/object:Gem::Version
-  version: 0.10.4
+  version: 0.10.5
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-06-28 00:00:00.000000000 Z
+date: 2013-08-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: multi_json
@@ -134,6 +134,7 @@ files:
 - lib/rollbar/better_errors.rb
 - lib/rollbar/capistrano.rb
 - lib/rollbar/configuration.rb
+- lib/rollbar/delay/sidekiq.rb
 - lib/rollbar/delayed_job.rb
 - lib/rollbar/exception_reporter.rb
 - lib/rollbar/goalie.rb