rollbar 2.1.2 → 2.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 553381499b916556da8272eadf551847254ffcaa
-  data.tar.gz: c80b393ccaa1cb9e2c2d46646703510852965ecf
+  metadata.gz: 245d598a698d57310a524065495b585450e183d8
+  data.tar.gz: ae4841097d594e0b58528806f3b151163e9b432a
 SHA512:
-  metadata.gz: d31b2d8d6d71c30c5888c3dacd631cda2f584d2de6a8b4cb238ca8c484a7037745904cfa5925ea5eca5e2100a93afa8c56681deab6292ffeefd97d4a764b078d
-  data.tar.gz: eedb32f0cc342297fbb7c48f989b8568bb6856ee385bc8f5d65c7d95334f58ed0a3121511d5824c870ddb1545e94fe8f2c265435a1afeb458730f2a2d927d581
+  metadata.gz: 43011a9710f91e3640dc5542d099b112ea4b2424842d2db8045a5f14444027ec225b15380539d7f38ecde2258744db6e74df31855b1a293c36d106c7ee2ac0dd
+  data.tar.gz: 47bfe86f356e5efa27fea9ef15c5150541d4c065c9d8c72f0def6c1ad2813d8ff0be5bc1381b0b9bea38f7df49f3fc3dfb03a3b23a362510da196a1391596668

data/CHANGELOG.md

@@ -1,5 +1,12 @@
 # Change Log
 
+## 2.2.0
+
+New features:
+
+- Raise internal exceptions when processing reports from async handlers, instead of swallowing them. This allows queue systems (e.g. Sidekiq, Resque) to track and retry errored jobs. See [#282](https://github.com/rollbar/rollbar-gem/pull/282)
+- Send the error class name when reporting internal errors. See [#283](https://github.com/rollbar/rollbar-gem/pull/283)
+
 ## 2.1.2
 
 Bug fix:

data/README.md

@@ -1,4 +1,4 @@
-# Rollbar notifier for Ruby [![Build Status](https://api.travis-ci.org/rollbar/rollbar-gem.svg?branch=v2.1.2)](https://travis-ci.org/rollbar/rollbar-gem/branches)
+# Rollbar notifier for Ruby [![Build Status](https://api.travis-ci.org/rollbar/rollbar-gem.svg?branch=v2.2.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.
@@ -12,7 +12,7 @@ This is the Ruby library for Rollbar. It will instrument many kinds of Ruby appl
 Add this line to your application's Gemfile:
 
 ```ruby
-gem 'rollbar', '~> 2.1.2'
+gem 'rollbar', '~> 2.2.0'
 ```
 
 And then execute:
@@ -518,11 +518,11 @@ You can supply your own handler using ```config.async_handler```. The object to
 ```ruby
 config.use_async = true
 config.async_handler = Proc.new { |payload|
-  Thread.new { Rollbar.process_payload_safely(payload) }
+  Thread.new { Rollbar.process_from_async_handler(payload) }
 }
 ```
 
-Make sure you pass ```payload``` to ```Rollbar.process_payload_safely``` in your own implementation.
+Make sure you pass ```payload``` to ```Rollbar.process_from_async_handler``` in your own implementation.
 
 ## Failover handlers
 
@@ -666,19 +666,6 @@ You can find upgrading notes in [UPGRADING.md](UPGRADING.md).
 
 ## Known Issues
 
-We've received some issues from users having problems when they use [Oj](https://github.com/ohler55/oj) as the JSON serialization library with [MultiJson](https://github.com/intridea/multi_json). To avoid these problems, we recommend upgrading to Oj version 2.11.0:
-
-```ruby
-gem 'oj', '~> 2.11.0'
-```
-
-If you are using Oj but cannot upgrade, you can work around this with:
-
-```ruby
-require 'json'
-MultiJson.use(:json_common)
-```
-
 If you are using jRuby with Oracle and JDK7, you may be expecting some errors sending reports to our API. This is caused by a bug in that JDK and the primer number used in the SSL algorithm. In order to fix this you can set the next configuration:
 
 ```ruby

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

@@ -47,7 +47,7 @@ Rollbar.configure do |config|
   # config.use_async = true
   # Supply your own async handler:
   # config.async_handler = Proc.new { |payload|
-  #  Thread.new { Rollbar.process_payload_safely(payload) }
+  #  Thread.new { Rollbar.process_from_async_handler(payload) }
   # }
 
   # Enable asynchronous reporting (using sucker_punch)

data/lib/rollbar.rb

@@ -17,7 +17,7 @@ require 'rollbar/logger_proxy'
 require 'rollbar/exception_reporter'
 require 'rollbar/util'
 require 'rollbar/railtie' if defined?(Rails::VERSION)
-require 'rollbar/delay/girl_friday'
+require 'rollbar/delay/girl_friday' if defined?(GirlFriday)
 require 'rollbar/delay/thread'
 require 'rollbar/truncation'
 
@@ -27,7 +27,7 @@ module Rollbar
     Rack::Multipart::UploadedFile
   ].freeze
   PUBLIC_NOTIFIER_METHODS = %w(debug info warn warning error critical log logger
-                               process_payload process_payload_safely scope send_failsafe log_info log_debug
+                               process_payload process_from_async_handler scope send_failsafe log_info log_debug
                                log_warning log_error silenced)
 
   class Notifier
@@ -195,10 +195,39 @@ module Rollbar
       raise e
     end
 
-    def process_payload_safely(payload)
-      process_payload(payload)
-    rescue => e
-      report_internal_error(e)
+    # We will reraise exceptions in this method so async queues
+    # can retry the job or, in general, handle an error report some way.
+    #
+    # At same time that exception is silenced so we don't generate
+    # infinite reports. This example is what we want to avoid:
+    #
+    # 1. New exception in a the project is raised
+    # 2. That report enqueued to Sidekiq queue.
+    # 3. The Sidekiq job tries to send the report to our API
+    # 4. The report fails, for example cause a network failure,
+    #    and a exception is raised
+    # 5. We report an internal error for that exception
+    # 6. We reraise the exception so Sidekiq job fails and
+    #    Sidekiq can retry the job reporting the original exception
+    # 7. Because the job failed and Sidekiq can be managed by rollbar we'll
+    #    report a new exception.
+    # 8. Go to point 2.
+    #
+    # We'll then push to Sidekiq queue indefinitely until the network failure
+    # is fixed.
+    #
+    # Using Rollbar.silenced we avoid the above behavior but Sidekiq
+    # will have a chance to retry the original job.
+    def process_from_async_handler(payload)
+      Rollbar.silenced do
+        begin
+          process_payload(payload)
+        rescue => e
+          report_internal_error(e)
+
+          raise
+        end
+      end
     end
 
     def custom_data
@@ -544,23 +573,28 @@ module Rollbar
     end
 
     def send_failsafe(message, exception)
+      body = 'Failsafe from rollbar-gem: '
       log_error "[Rollbar] Sending failsafe response due to #{message}."
+
       if exception
         begin
+          body += "#{exception.class.name}: #{message}"
           log_error "[Rollbar] #{exception.class.name}: #{exception}"
-        rescue => e
+        rescue
+        end
+      else
+        begin
+          body += message.to_s
+        rescue
         end
       end
 
-      config = configuration
-      environment = config.environment
-
       failsafe_data = {
         :level => 'error',
-        :environment => environment.to_s,
+        :environment => configuration.environment.to_s,
         :body => {
           :message => {
-            :body => "Failsafe from rollbar-gem: #{message}"
+            :body => body
           }
         },
         :notifier => {
@@ -581,6 +615,8 @@ module Rollbar
       rescue => e
         log_error "[Rollbar] Error sending failsafe : #{e}"
       end
+
+      failsafe_payload
     end
 
     def schedule_payload(payload)

data/lib/rollbar/delay/girl_friday.rb

@@ -3,22 +3,28 @@ module Rollbar
     class GirlFriday
 
       class << self
-        attr_accessor :queue
+        def queue_class
+          ::GirlFriday::WorkQueue
+        end
 
         def call(payload)
           new.call(payload)
         end
-      end
 
-      def queue_class
-        ::GirlFriday::WorkQueue
+        def queue
+          @queue ||= self.queue_class.new(nil, :size => 5) do |payload|
+            begin
+              Rollbar.process_from_async_handler(payload)
+            rescue
+              # According to https://github.com/mperham/girl_friday/wiki#error-handling
+              # we reraise the exception so it can be handled some way
+              raise
+            end
+          end
+        end
       end
 
       def call(payload)
-        self.class.queue = queue_class.new(nil, :size => 5) do |payload|
-          Rollbar.process_payload_safely(payload)
-        end
-
         self.class.queue.push(payload)
       end
     end

data/lib/rollbar/delay/resque.rb

@@ -23,7 +23,12 @@ module Rollbar
         end
 
         def perform(payload)
-          Rollbar.process_payload_safely(payload)
+          begin
+            Rollbar.process_from_async_handler(payload)
+          rescue
+            # Raise the exception so Resque can track the errored job
+            raise
+          end
         end
       end
     end

data/lib/rollbar/delay/sidekiq.rb

@@ -16,7 +16,13 @@ module Rollbar
       include ::Sidekiq::Worker
 
       def perform(*args)
-        Rollbar.process_payload_safely(*args)
+        begin
+          Rollbar.process_from_async_handler(*args)
+        rescue
+          # Raise the exception so Sidekiq can track the errored job
+          # and retry it
+          raise
+        end
       end
     end
   end

data/lib/rollbar/delay/sucker_punch.rb

@@ -11,7 +11,20 @@ module Rollbar
       end
 
       def perform(*args)
-        Rollbar.process_payload_safely(*args)
+        begin
+          Rollbar.process_from_async_handler(*args)
+        rescue
+          # SuckerPunch can configure an exception handler with:
+          #
+          # SuckerPunch.exception_handler { # do something here }
+          #
+          # This is just passed to Celluloid.exception_handler which will
+          # push the reiceved block to an array of handlers, by default empty, [].
+          #
+          # We reraise the exception here casue it's safe and users could have defined
+          # their own exception handler for SuckerPunch
+          raise
+        end
       end
     end
   end

data/lib/rollbar/delay/thread.rb

@@ -6,7 +6,18 @@ module Rollbar
       end
 
       def call(payload)
-        ::Thread.new { Rollbar.process_payload_safely(payload) }
+        ::Thread.new do
+          begin
+            Rollbar.process_from_async_handler(payload)
+          rescue
+            # Here we swallow the exception:
+            # 1. The original report wasn't sent.
+            # 2. An internal error was sent and logged
+            #
+            # If users want to handle this in some way they
+            # can provide a more custom Thread based implementation
+          end
+        end
       end
     end
   end

data/lib/rollbar/version.rb

@@ -1,3 +1,3 @@
 module Rollbar
-  VERSION = "2.1.2"
+  VERSION = "2.2.0"
 end

data/rollbar.gemspec

@@ -4,7 +4,7 @@ require File.expand_path('../lib/rollbar/version', __FILE__)
 Gem::Specification.new do |gem|
   gem.authors       = ["Rollbar, Inc."]
   gem.email         = ["support@rollbar.com"]
-  gem.description   = %q{Rails plugin to catch and send exceptions to Rollbar}
+  gem.description   = %q{Easy and powerful exception tracking for Ruby}
   gem.executables   = ['rollbar-rails-runner']
   gem.summary       = %q{Reports exceptions to Rollbar}
   gem.homepage      = "https://rollbar.com"

data/spec/delay/sidekiq_spec.rb

@@ -17,7 +17,7 @@ describe Rollbar::Delay::Sidekiq, :if => RUBY_VERSION != '1.8.7' do
 
   describe "#perform" do
     it "performs payload" do
-      Rollbar.should_receive(:process_payload_safely).with(payload)
+      Rollbar.should_receive(:process_from_async_handler).with(payload)
       subject.perform payload
     end
   end
@@ -26,7 +26,7 @@ describe Rollbar::Delay::Sidekiq, :if => RUBY_VERSION != '1.8.7' do
     shared_examples "a Rollbar processor" do
 
       it "processes payload" do
-        Rollbar.should_receive(:process_payload_safely).with(payload)
+        Rollbar.should_receive(:process_from_async_handler).with(payload)
 
         subject.call payload
         described_class.drain

data/spec/delay/sucker_punch_spec.rb

@@ -17,7 +17,7 @@ describe Rollbar::Delay::SuckerPunch, :if => RUBY_VERSION != '1.8.7' do
     let(:payload) { "anything" }
 
     it "performs the task asynchronously" do
-      Rollbar.should_receive(:process_payload_safely)
+      Rollbar.should_receive(:process_from_async_handler)
 
       Rollbar::Delay::SuckerPunch.call payload
     end

data/spec/rollbar/delay/girl_friday_spec.rb

@@ -6,14 +6,36 @@ require 'girl_friday'
 require 'rollbar/delay/girl_friday'
 
 describe Rollbar::Delay::GirlFriday do
+  before do
+    queue_class = ::GirlFriday::WorkQueue.immediate!
+    allow(::Rollbar::Delay::GirlFriday).to receive(:queue_class).and_return(queue_class)
+  end
+
   describe '.call' do
     let(:payload) do
       { :key => 'value' }
     end
 
     it 'push the payload into the queue' do
-      expect_any_instance_of(::GirlFriday::WorkQueue).to receive(:push).with(payload)
+      expect(Rollbar).to receive(:process_from_async_handler).with(payload)
+
       described_class.call(payload)
     end
+
+    context 'with exceptions processing payload' do
+      let(:exception) { Exception.new }
+
+      before do
+        expect(Rollbar).to receive(:process_from_async_handler).with(payload).and_raise(exception)
+      end
+
+      it 'raises an exception cause we are using immediate queue' do
+        # This will not happen with a norma work queue cause this:
+        # https://github.com/mperham/girl_friday/blob/master/lib/girl_friday/work_queue.rb#L90-L106
+        expect do
+          described_class.call(payload)
+        end.to raise_error(exception)
+      end
+    end
   end
 end

data/spec/rollbar/delay/resque_spec.rb

@@ -7,15 +7,31 @@ describe Rollbar::Delay::Resque do
       { :key => 'value' }
     end
 
+    let(:loaded_hash) do
+      Rollbar::JSON.load(Rollbar::JSON.dump(payload))
+    end
+
     before do
       allow(Resque).to receive(:inline?).and_return(true)
     end
 
     it 'process the payload' do
-      loaded_hash = Rollbar::JSON.load(Rollbar::JSON.dump(payload))
-
-      expect(Rollbar).to receive(:process_payload_safely).with(loaded_hash)
+      expect(Rollbar).to receive(:process_from_async_handler).with(loaded_hash)
       described_class.call(payload)
     end
+
+    context 'with exceptions processing payload' do
+      let(:exception) { Exception.new }
+
+      before do
+        expect(Rollbar).to receive(:process_from_async_handler).with(loaded_hash).and_raise(exception)
+      end
+
+      it 'raises an exception' do
+        expect do
+          described_class.call(payload)
+        end.to raise_error(exception)
+      end
+    end
   end
 end

data/spec/rollbar/delay/thread_spec.rb

@@ -5,10 +5,23 @@ describe Rollbar::Delay::Thread do
     let(:payload) { { :key => 'value' } }
 
     it 'process the payload in a new thread' do
-      expect(Rollbar).to receive(:process_payload_safely).with(payload)
+      expect(Rollbar).to receive(:process_from_async_handler).with(payload)
 
-      th = described_class.call(payload)
-      th.join
+      described_class.call(payload).join
+    end
+
+    context 'with exceptions processing payload' do
+      let(:exception) { StandardError.new }
+
+      before do
+        expect(Rollbar).to receive(:process_from_async_handler).with(payload).and_raise(exception)
+      end
+
+      it 'doesnt raise any exception' do
+        expect do
+          described_class.call(payload).join
+        end.not_to raise_error(exception)
+      end
     end
   end
 end

data/spec/rollbar_spec.rb

@@ -1562,17 +1562,27 @@ describe Rollbar do
   end
 
   context "send_failsafe" do
+    let(:exception) { StandardError.new }
+
     it "should not crash when given a message and exception" do
-      begin
-        1 / 0
-      rescue => e
-        notifier.send(:send_failsafe, "test failsafe", e)
-      end
+      sent_payload = notifier.send(:send_failsafe, "test failsafe", exception)
+
+      expected_message = 'Failsafe from rollbar-gem: StandardError: test failsafe'
+      expect(sent_payload['data'][:body][:message][:body]).to be_eql(expected_message)
     end
 
     it "should not crash when given all nils" do
       notifier.send(:send_failsafe, nil, nil)
     end
+
+    context 'without exception object' do
+      it 'just sends the given message' do
+        sent_payload = notifier.send(:send_failsafe, "test failsafe", nil)
+
+        expected_message = 'Failsafe from rollbar-gem: test failsafe'
+        expect(sent_payload['data'][:body][:message][:body]).to be_eql(expected_message)
+      end
+    end
   end
 
   context 'when reporting internal error with nil context' do
@@ -1704,15 +1714,20 @@ describe Rollbar do
     end
   end
 
-  describe '.process_payload_safely' do
+  describe '.process_from_async_handler' do
     context 'with errors' do
       let(:exception) { StandardError.new('the error') }
 
-      it 'doesnt raise anything and sends internal error' do
+      it 'raises anything and sends internal error' do
         allow(Rollbar.notifier).to receive(:process_payload).and_raise(exception)
         expect(Rollbar.notifier).to receive(:report_internal_error).with(exception)
 
-        Rollbar.notifier.process_payload_safely({})
+        expect do
+          Rollbar.notifier.process_from_async_handler({})
+        end.to raise_error(exception)
+
+        rollbar_do_not_report = exception.instance_variable_get(:@_rollbar_do_not_report)
+        expect(rollbar_do_not_report).to be_eql(true)
       end
     end
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rollbar
 version: !ruby/object:Gem::Version
-  version: 2.1.2
+  version: 2.2.0
 platform: ruby
 authors:
 - Rollbar, Inc.
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-08-14 00:00:00.000000000 Z
+date: 2015-08-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -178,7 +178,7 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-description: Rails plugin to catch and send exceptions to Rollbar
+description: Easy and powerful exception tracking for Ruby
 email:
 - support@rollbar.com
 executables: