rollbar 2.8.3 → 3.6.0

data/spec/rollbar/logger_proxy_spec.rb

@@ -1,34 +0,0 @@
-require 'spec_helper'
-
-describe Rollbar::LoggerProxy do
-  let(:logger) { double(:logger) }
-  let(:message) { 'the-message' }
-
-  subject { described_class.new(logger) }
-
-  shared_examples 'delegate to logger' do
-    it 'logs with correct level' do
-      expect(logger).to receive(level).with(message)
-
-      subject.send(level, message)
-    end
-  end
-
-  %w(info error warn debug).each do |level|
-    describe "#{level}" do
-      it_should_behave_like 'delegate to logger' do
-        let(:level) { level }
-      end
-    end
-  end
-
-  describe '#call' do
-    context 'if the logger fails' do
-      it 'doesnt raise' do
-        allow(logger).to receive(:info).and_raise(StandardError.new)
-
-        expect { subject.log('info', message) }.not_to raise_error
-      end
-    end
-  end
-end

data/spec/rollbar/middleware/rack/builder_spec.rb

@@ -1,151 +0,0 @@
-require 'spec_helper'
-require 'rack'
-require 'rack/builder'
-require 'rack/mock'
-require 'rollbar/middleware/rack/builder'
-
-
-describe Rollbar::Middleware::Rack::Builder, :reconfigure_notifier => true do
-  class RackMockError < Exception; end
-
-  let(:action) do
-    proc { fail(RackMockError, 'the-error') }
-  end
-
-  let(:app) do
-    action_proc = action
-
-    Rack::Builder.new { run action_proc }
-  end
-
-  let(:request) do
-    Rack::MockRequest.new(app)
-  end
-
-  let(:exception) { kind_of(RackMockError) }
-  let(:uncaught_level) { Rollbar.configuration.uncaught_exception_level }
-
-  it 'reports the error to Rollbar' do
-    expect(Rollbar).to receive(:log).with(uncaught_level, exception, :use_exception_level_filters => true)
-    expect { request.get('/will_crash') }.to raise_error(exception)
-  end
-
-  context 'with GET parameters' do
-    let(:params) do
-      { 'key' => 'value' }
-    end
-
-    it 'sends them to Rollbar' do
-      expect do
-        request.get('/will_crash', :params => params)
-      end.to raise_error(exception)
-
-      expect(Rollbar.last_report[:request][:params]).to be_eql(params)
-    end
-  end
-
-  context 'with POST parameters' do
-    let(:params) do
-      { 'key' => 'value' }
-    end
-
-    it 'sends them to Rollbar' do
-      expect do
-        request.post('/will_crash', :input => params.to_json, 'CONTENT_TYPE' => 'application/json')
-      end.to raise_error(exception)
-
-      expect(Rollbar.last_report[:request][:params]).to be_eql(params)
-    end
-  end
-
-  context 'with array POST parameters' do
-    let(:params) do
-      [{ :key => 'value'}, 'string', 10]
-    end
-
-    it 'sends a body.multi key in params' do
-      expect do
-        request.post('/will_crash', :input => params.to_json, 'CONTENT_TYPE' => 'application/json')
-      end.to raise_error(exception)
-
-      reported_params = Rollbar.last_report[:request][:params]
-      expect(reported_params['body.multi']).to be_eql([{'key' => 'value'}, 'string', 10])
-    end
-  end
-
-  context 'with not array or hash POST parameters' do
-    let(:params) { 1000 }
-
-    it 'sends a body.multi key in params' do
-      expect do
-        request.post('/will_crash', :input => params.to_json, 'CONTENT_TYPE' => 'application/json')
-      end.to raise_error(exception)
-
-      reported_params = Rollbar.last_report[:request][:params]
-      expect(reported_params['body.value']).to be_eql(1000)
-    end
-  end
-
-  context 'with multiple HTTP_X_FORWARDED_PROTO values' do
-    let(:headers) do
-      { 'HTTP_X_FORWARDED_PROTO' => 'https,http' }
-    end
-
-    it 'uses the first scheme to generate the url' do
-      expect do
-        request.post('/will_crash', headers)
-      end.to raise_error(exception)
-
-      last_report = Rollbar.last_report
-      expect(last_report[:request][:url]).to match(/https:/)
-    end
-  end
-
-  context 'without HTTP_X_FORWARDED_PROTO' do
-    it 'uses the the url_scheme set by Rack' do
-      expect do
-        request.post('/will_crash')
-      end.to raise_error(exception)
-
-      last_report = Rollbar.last_report
-      expect(last_report[:request][:url]).to match(/http:/)
-    end
-  end
-
-  context 'with single HTTP_X_FORWARDED_PROTO value' do
-    let(:headers) do
-      { 'HTTP_X_FORWARDED_PROTO' => 'https' }
-    end
-
-    it 'uses the scheme received in X-Forwarded-Proto header' do
-      expect do
-        request.post('/will_crash', headers)
-      end.to raise_error(exception)
-
-      last_report = Rollbar.last_report
-      expect(last_report[:request][:url]).to match(/https:/)
-    end
-  end
-
-  context 'with person data' do
-    let(:person_data) do
-      { 'email' => 'person@example.com' }
-    end
-
-    it 'includes person data from env' do
-      expect do
-        request.get('/will_crash', 'rollbar.person_data' => person_data)
-      end.to raise_error(exception)
-
-      expect(Rollbar.last_report[:person]).to be_eql(person_data)
-    end
-
-    it 'includes empty person data when not in env' do
-      expect do
-        request.get('/will_crash')
-      end.to raise_error(exception)
-
-      expect(Rollbar.last_report[:person]).to be_eql({})
-    end
-  end
-end

data/spec/rollbar/middleware/sinatra_spec.rb

@@ -1,197 +0,0 @@
-require 'spec_helper'
-require 'rollbar/middleware/sinatra'
-require 'sinatra/base'
-require 'rack/test'
-
-class SinatraDummy < Sinatra::Base
-  class DummyError < StandardError; end
-
-  use Rollbar::Middleware::Sinatra
-
-  get '/foo' do
-    raise DummyError.new
-  end
-
-  get '/bar' do
-    'this will not crash'
-  end
-
-  post '/crash_post' do
-    raise DummyError.new
-  end
-end
-
-describe Rollbar::Middleware::Sinatra, :reconfigure_notifier => true do
-  include Rack::Test::Methods
-
-  def app
-    SinatraDummy
-  end
-
-  let(:logger_mock) { double('logger').as_null_object }
-
-  before do
-    Rollbar.configure do |config|
-      config.logger = logger_mock
-      config.framework = 'Sinatra'
-    end
-  end
-
-  let(:uncaught_level) do
-    Rollbar.configuration.uncaught_exception_level
-  end
-
-  let(:expected_report_args) do
-    [uncaught_level, exception, { :use_exception_level_filters => true }]
-  end
-
-  describe '#call' do
-    context 'for a crashing endpoint' do
-      # this is the default for test mode in Sinatra
-      context 'with raise_errors? == true' do
-        let(:exception) { kind_of(SinatraDummy::DummyError) }
-
-        before do
-          allow(app.settings).to receive(:raise_errors?).and_return(true)
-        end
-
-        it 'reports the error to Rollbar API and raises error' do
-          expect(Rollbar).to receive(:log).with(*expected_report_args)
-
-          expect do
-            get '/foo'
-          end.to raise_error(SinatraDummy::DummyError)
-        end
-      end
-
-      context 'with raise_errors? == false' do
-        let(:exception) { kind_of(SinatraDummy::DummyError) }
-
-        before do
-          allow(app.settings).to receive(:raise_errors?).and_return(false)
-        end
-
-        it 'reports the error to Rollbar, but nothing is raised' do
-          expect(Rollbar).to receive(:log).with(*expected_report_args)
-          get '/foo'
-        end
-      end
-    end
-
-    context 'for a NOT crashing endpoint' do
-      it 'doesnt report any error to Rollbar API' do
-        expect(Rollbar).not_to receive(:log)
-        get '/bar'
-      end
-    end
-
-    context 'if the middleware itself fails' do
-      let(:exception) { Exception.new }
-
-      before do
-        allow_any_instance_of(described_class).to receive(:framework_error).and_raise(exception)
-        allow(app.settings).to receive(:raise_errors?).and_return(false)
-      end
-
-      it 'reports the report error' do
-        expect(Rollbar).to receive(:log).with(*expected_report_args)
-
-        expect do
-          get '/foo'
-        end.to raise_error(exception)
-      end
-    end
-
-    context 'with GET parameters' do
-      let(:exception) { kind_of(SinatraDummy::DummyError) }
-      let(:params) do
-        {
-          'key' => 'value'
-        }
-      end
-
-      it 'appear in the sent payload' do
-        expect do
-          get '/foo', params
-        end.to raise_error(exception)
-
-        expect(Rollbar.last_report[:request][:params]).to be_eql(params)
-      end
-    end
-
-    context 'with POST parameters' do
-      let(:exception) { kind_of(SinatraDummy::DummyError) }
-      let(:params) do
-        {
-          'key' => 'value'
-        }
-      end
-
-      it 'appear in the sent payload' do
-        expect do
-          post '/crash_post', params
-        end.to raise_error(exception)
-
-        expect(Rollbar.last_report[:request][:params]).to be_eql(params)
-      end
-    end
-
-    context 'with JSON POST parameters' do
-      let(:exception) { kind_of(SinatraDummy::DummyError) }
-      let(:params) do
-        {
-          'key' => 'value'
-        }
-      end
-
-      it 'appears in the sent payload when application/json is the content type' do
-        expect do
-          post '/crash_post', params.to_json, { 'CONTENT_TYPE' => 'application/json' }
-        end.to raise_error(exception)
-
-        expect(Rollbar.last_report[:request][:params]).to be_eql(params)
-      end
-
-      it 'appears in the sent payload when the accepts header contains json' do
-        expect do
-          post '/crash_post', params, { 'ACCEPT' => 'application/vnd.github.v3+json' }
-        end.to raise_error(exception)
-
-        expect(Rollbar.last_report[:request][:params]).to be_eql(params)
-      end
-    end
-
-    it 'resets the notifier in every request' do
-      get '/bar'
-      id1 = Rollbar.notifier.object_id
-
-      get '/bar'
-      id2 = Rollbar.notifier.object_id
-
-      expect(id1).not_to be_eql(id2)
-    end
-
-    context 'with person data' do
-      let(:exception) { kind_of(SinatraDummy::DummyError) }
-      let(:person_data) do
-        { 'email' => 'person@example.com' }
-      end
-
-      it 'includes person data from env' do
-        expect do
-          get '/foo', {}, 'rollbar.person_data' => person_data
-        end.to raise_error(exception)
-
-        expect(Rollbar.last_report[:person]).to be_eql(person_data)
-      end
-
-      it 'includes empty person data when not in env' do
-        expect do
-          get '/foo'
-        end.to raise_error(exception)
-
-        expect(Rollbar.last_report[:person]).to be_eql({})
-      end
-    end
-  end
-end

data/spec/rollbar/rake_spec.rb

@@ -1,34 +0,0 @@
-require 'spec_helper'
-require 'rollbar/rake'
-
-describe Rollbar::Rake do
-  let(:application) { Rake::Application.new }
-  let(:exception) { Exception.new }
-
-  context 'with supported rake version' do
-    before do
-      allow(Rollbar::Rake).to receive(:rake_version).and_return('0.9.0')
-    end
-
-    it 'reports error to Rollbar' do
-      expect(Rollbar::Rake).not_to receive(:skip_patch)
-      expect(Rollbar).to receive(:error).with(exception, :use_exception_level_filters => true)
-      expect(application).to receive(:orig_display_error_message).with(exception)
-
-      Rollbar::Rake.patch! # Really here Rake is already patched
-      application.display_error_message(exception)
-    end
-  end
-
-  context 'with unsupported rake version' do
-    before do
-      allow(Rollbar::Rake).to receive(:rake_version).and_return('0.8.7')
-    end
-
-    it 'reports error to Rollbar' do
-      expect(Rollbar::Rake).to receive(:skip_patch)
-
-      Rollbar::Rake.patch!
-    end
-  end
-end

data/spec/rollbar/request_data_extractor_spec.rb

@@ -1,82 +0,0 @@
-require 'spec_helper'
-require 'rack/mock'
-
-require 'rollbar/request_data_extractor'
-
-class ExtractorDummy
-  include Rollbar::RequestDataExtractor
-end
-
-describe Rollbar::RequestDataExtractor do
-  subject { ExtractorDummy.new }
-
-  let(:env) do
-    Rack::MockRequest.env_for('/', 'HTTP_HOST' => 'localhost:81', 'HTTP_X_FORWARDED_HOST' => 'example.org:9292')
-  end
-
-  describe '#extract_request_data_from_rack' do
-    let(:scrubber) { double }
-
-    it 'returns a Hash object' do
-      scrubber_config = {
-        :scrub_fields => kind_of(Array),
-        :scrub_user => Rollbar.configuration.scrub_user,
-        :scrub_password => Rollbar.configuration.scrub_password,
-        :randomize_scrub_length => Rollbar.configuration.randomize_scrub_length
-      }
-      expect(Rollbar::Scrubbers::URL).to receive(:new).with(scrubber_config).and_return(scrubber)
-      expect(scrubber).to receive(:call).with(kind_of(String))
-
-      result = subject.extract_request_data_from_rack(env)
-
-      expect(result).to be_kind_of(Hash)
-    end
-
-    context 'with invalid utf8 sequence in key', :if => RUBY_VERSION != '1.8.7'  do
-      let(:data) do
-        File.read(File.expand_path('../../support/encodings/iso_8859_9', __FILE__)).force_encoding(Encoding::ISO_8859_9)
-      end
-      let(:env) do
-        env = Rack::MockRequest.env_for('/',
-                                         'HTTP_HOST' => 'localhost:81',
-                                         'HTTP_X_FORWARDED_HOST' => 'example.org:9292',
-                                         'CONTENT_TYPE' => 'application/json')
-
-        env['rack.session'] = { data => 'foo' }
-        env
-      end
-
-      it 'doesnt crash' do
-        result = subject.extract_request_data_from_rack(env)
-
-        expect(result).to be_kind_of(Hash)
-      end
-    end
-  end
-
-  describe '#rollbar_scrubbed_value' do
-    context 'with random scrub length' do
-      before do
-        allow(Rollbar.configuration).to receive(:randomize_scrub_length).and_return(true)
-      end
-
-      let(:value) { 'herecomesaverylongvalue' }
-
-      it 'randomizes the scrubbed string' do
-        expect(subject.rollbar_scrubbed(value)).to match(/\*{3,8}/)
-      end
-    end
-
-    context 'with no-random scrub length' do
-      before do
-        allow(Rollbar.configuration).to receive(:randomize_scrub_length).and_return(false)
-      end
-
-      let(:value) { 'herecomesaverylongvalue' }
-
-      it 'randomizes the scrubbed string' do
-        expect(subject.rollbar_scrubbed(value)).to match(/\*{#{value.length}}/)
-      end
-    end
-  end
-end

data/spec/rollbar/scrubbers/url_spec.rb

@@ -1,111 +0,0 @@
-require 'spec_helper'
-require 'rollbar/language_support'
-require 'rollbar/scrubbers/url'
-
-describe Rollbar::Scrubbers::URL do
-  let(:options) do
-    { :scrub_fields => [:password, :secret],
-      :scrub_user => false,
-      :scrub_password => false,
-      :randomize_scrub_length => true
-    }
-  end
-
-  subject { described_class.new(options) }
-
-  describe '#call' do
-    context 'cannot scrub URLs' do
-      next if Rollbar::LanguageSupport.can_scrub_url?
-
-      let(:url) { 'http://user:password@foo.com/some-interesting-path#fragment' }
-
-      it 'returns the URL without any change' do
-        expect(subject.call(url)).to be_eql(url)
-      end
-    end
-
-    context 'with ruby different from 1.8' do
-      next unless Rollbar::LanguageSupport.can_scrub_url?
-
-      context 'without data to be scrubbed' do
-        let(:url) { 'http://user:password@foo.com/some-interesting-path#fragment' }
-
-        it 'returns the URL without any change' do
-          expect(subject.call(url)).to be_eql(url)
-        end
-
-        context 'with arrays in params' do
-          let(:url) { 'http://user:password@foo.com/some-interesting-path?foo[]=1&foo[]=2' }
-
-          it 'returns the URL without any change' do
-            expect(subject.call(url)).to be_eql(url)
-          end
-        end
-      end
-
-      context 'scrubbing user and password' do
-        let(:options) do
-          {
-            :scrub_fields => [],
-            :scrub_password => true,
-            :scrub_user => true
-          }
-        end
-
-        let(:url) { 'http://user:password@foo.com/some-interesting-path#fragment' }
-
-        it 'returns the URL without any change' do
-          expected_url = /http:\/\/\*{3,8}:\*{3,8}@foo.com\/some-interesting\-path#fragment/
-
-          expect(subject.call(url)).to match(expected_url)
-        end
-      end
-
-      context 'with params to be filtered' do
-        let(:url) { 'http://foo.com/some-interesting-path?foo=bar&password=mypassword&secret=somevalue#fragment' }
-
-        it 'returns the URL with some params filtered' do
-          expected_url = /http:\/\/foo.com\/some-interesting-path\?foo=bar&password=\*{3,8}&secret=\*{3,8}#fragment/
-
-          expect(subject.call(url)).to match(expected_url)
-        end
-
-        context 'having array params' do
-          let(:url) { 'http://foo.com/some-interesting-path?foo=bar&password[]=mypassword&password[]=otherpassword&secret=somevalue#fragment' }
-
-          it 'returns the URL with some params filtered' do
-            expected_url = /http:\/\/foo.com\/some-interesting-path\?foo=bar&password\[\]=\*{3,8}&password\[\]=\*{3,8}&secret=\*{3,8}#fragment/
-
-            expect(subject.call(url)).to match(expected_url)
-          end
-        end
-      end
-
-      context 'with no-random scrub length' do
-        let(:options) do
-          { :scrub_fields => [:password, :secret],
-            :scrub_user => false,
-            :scrub_password => false,
-            :randomize_scrub_length => false
-          }
-        end
-        let(:password) { 'longpasswordishere' }
-        let(:url) { "http://foo.com/some-interesting-path?foo=bar&password=#{password}#fragment" }
-
-        it 'scrubs with same length than the scrubbed param' do
-          expected_url = /http:\/\/foo.com\/some-interesting-path\?foo=bar&password=\*{#{password.length}}#fragment/
-
-          expect(subject.call(url)).to match(expected_url)
-        end
-      end
-
-      context 'with malformed URL or not able to be parsed' do
-        let(:url) { '\this\is\not\a\valid\url' }
-
-        it 'return the same url' do
-          expect(subject.call(url)).to be_eql(url)
-        end
-      end
-    end
-  end
-end

data/spec/rollbar/sidekiq_spec.rb

@@ -1,90 +0,0 @@
-require 'spec_helper'
-
-unless RUBY_VERSION == '1.8.7'
-  require 'sidekiq'
-  require 'rollbar/sidekiq'
-end
-
-describe Rollbar::Sidekiq, :reconfigure_notifier => false do
-  describe '.handle_exception' do
-    let(:msg_or_context) { ['hello', 'error_backtrace', 'backtrace', 'goodbye'] }
-    let(:exception) { StandardError.new('oh noes') }
-    let(:rollbar) { double }
-    let(:expected_args) { { :request => { :params => ['hello', 'goodbye'] } } }
-
-    subject { described_class }
-
-    it 'constructs scope from filtered params' do
-      allow(rollbar).to receive(:error)
-      expect(Rollbar).to receive(:scope).with(expected_args) {rollbar}
-
-      described_class.handle_exception(msg_or_context, exception)
-    end
-
-    it 'sends the passed-in error to rollbar' do
-      allow(Rollbar).to receive(:scope).and_return(rollbar)
-      expect(rollbar).to receive(:error).with(exception, :use_exception_level_filters => true)
-
-      described_class.handle_exception(msg_or_context, exception)
-    end
-
-    context 'when set a sidekiq_threshold' do
-      before do
-        Rollbar.configuration.sidekiq_threshold = 2
-      end
-
-      it 'does not send error to rollbar under the threshold' do
-        allow(Rollbar).to receive(:scope).and_return(rollbar)
-        expect(rollbar).to receive(:error).never
-
-        msg_or_context = {"retry" => true, "retry_count" => 1}
-
-        described_class.handle_exception(msg_or_context, exception)
-      end
-
-      it 'sends the error to rollbar above the threshold' do
-        allow(Rollbar).to receive(:scope).and_return(rollbar)
-        expect(rollbar).to receive(:error)
-
-        msg_or_context = {"retry" => true, "retry_count" => 2}
-
-        described_class.handle_exception(msg_or_context, exception)
-      end
-
-      it 'sends the error to rollbar if not retry' do
-        allow(Rollbar).to receive(:scope).and_return(rollbar)
-        expect(rollbar).to receive(:error)
-
-        msg_or_context = {"retry" => false}
-
-        described_class.handle_exception(msg_or_context, exception)
-      end
-      
-      it 'does not blow up and sends the error to rollbar if retry is true but there is no retry count' do
-        allow(Rollbar).to receive(:scope).and_return(rollbar)
-        expect(rollbar).to receive(:error)
-
-        msg_or_context = {"retry" => true}
-
-        expect {
-          described_class.handle_exception(msg_or_context, exception)
-        }.to_not raise_error
-      end
-      
-    end
-  end
-
-  describe '#call' do
-    let(:msg) { ['hello'] }
-    let(:exception) { StandardError.new('oh noes') }
-    let(:middleware_block) { proc { raise exception } }
-
-    subject { Rollbar::Sidekiq.new }
-
-    it 'sends the error to Rollbar::Sidekiq.handle_exception' do
-      expect(Rollbar::Sidekiq).to receive(:handle_exception).with(msg, exception)
-
-      expect { subject.call(nil, msg, nil, &middleware_block) }.to raise_error(exception)
-    end
-  end
-end unless RUBY_VERSION == '1.8.7'