def process_from_async_handler(payload)
      payload = Rollbar::JSON.load(payload) if payload.is_a?(String)

      item = Item.build_with(payload,
                             :notifier => self,
                             :configuration => configuration,
                             :logger => logger)

      Rollbar.silenced do
        begin
          process_item(item)
        rescue StandardError => e
          report_internal_error(e)

          raise
        end
      end
    end
def process_from_async_handler(payload)
      payload = Rollbar::JSON.load(payload) if payload.is_a?(String)

      item = Item.build_with(payload,
                             :notifier => self,
                             :configuration => configuration,
                             :logger => logger)

      Rollbar.silenced do
        begin
          process_item(item)
        rescue StandardError => e
          report_internal_error(e)

          raise
        end
      end
    end
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.