bugsnag 4.2.1 → 6.27.1

data/lib/bugsnag/railtie.rb

@@ -1,80 +0,0 @@
-# Rails 3.x hooks
-
-require "rails"
-require "bugsnag"
-require "bugsnag/middleware/rails3_request"
-require "bugsnag/middleware/rack_request"
-
-module Bugsnag
-  class Railtie < Rails::Railtie
-    cattr_accessor :running_as_dependency
-
-    rake_tasks do
-      require "bugsnag/rake"
-      load "bugsnag/tasks/bugsnag.rake"
-    end
-
-    # send notifications if a command fails in a 'rails runner' call
-    if self.respond_to? :runner
-      runner do
-        at_exit do
-          if $!
-            Bugsnag.auto_notify($!)
-          end
-        end
-      end
-    end
-
-    config.before_initialize do
-      # Configure bugsnag rails defaults
-      Bugsnag.configure do |config|
-        config.logger = ::Rails.logger
-        config.release_stage = ::Rails.env.to_s
-        config.project_root = ::Rails.root.to_s
-        config.middleware.insert_before Bugsnag::Middleware::Callbacks, Bugsnag::Middleware::Rails3Request
-      end
-
-      # Auto-load configuration settings from config/bugsnag.yml if it exists
-      config_file = ::Rails.root.join("config", "bugsnag.yml")
-      config = YAML.load_file(config_file) if File.exists?(config_file)
-      Bugsnag.configure(config[::Rails.env] ? config[::Rails.env] : config) if config
-
-      if defined?(::ActionController::Base)
-        require "bugsnag/rails/controller_methods"
-        ::ActionController::Base.send(:include, Bugsnag::Rails::ControllerMethods)
-      end
-      if defined?(ActionController::API)
-        ActionController::API.send(:include, Bugsnag::Rails::ControllerMethods)
-      end
-      if defined?(ActiveRecord::Base)
-        require "bugsnag/rails/active_record_rescue"
-        ActiveRecord::Base.send(:include, Bugsnag::Rails::ActiveRecordRescue)
-      end
-
-      Bugsnag.configuration.app_type = "rails" unless Bugsnag::Railtie.running_as_dependency
-    end
-
-    # Configure params_filters after initialization, so that rails initializers
-    # may set filter_parameters which will be picked up by Bugsnag.
-    config.after_initialize do
-      Bugsnag.configure do |config|
-        config.params_filters += ::Rails.configuration.filter_parameters.map do |filter|
-          case filter
-          when String, Symbol
-            /\A#{filter}\z/
-          else
-            filter
-          end
-        end
-      end
-    end
-
-    initializer "bugsnag.use_rack_middleware" do |app|
-      begin
-        app.config.middleware.insert_after ActionDispatch::DebugExceptions, Bugsnag::Rack
-      rescue
-        app.config.middleware.use Bugsnag::Rack
-      end
-    end
-  end
-end

data/lib/bugsnag/rake.rb

@@ -1,25 +0,0 @@
-require 'bugsnag'
-
-Rake::TaskManager.record_task_metadata = true
-
-class Rake::Task
-
-  def execute_with_bugsnag(args=nil)
-    Bugsnag.configuration.app_type = "rake"
-    old_task = Bugsnag.configuration.request_data[:bugsnag_running_task]
-    Bugsnag.set_request_data :bugsnag_running_task, self
-
-    execute_without_bugsnag(args)
-
-  rescue Exception => ex
-    Bugsnag.auto_notify(ex)
-    raise
-  ensure
-    Bugsnag.set_request_data :bugsnag_running_task, old_task
-  end
-
-  alias_method :execute_without_bugsnag, :execute
-  alias_method :execute, :execute_with_bugsnag
-end
-
-Bugsnag.configuration.internal_middleware.use(Bugsnag::Middleware::Rake)

data/lib/bugsnag/resque.rb

@@ -1,40 +0,0 @@
-require "resque"
-require "resque/failure/multiple"
-
-module Bugsnag
-  class Resque < ::Resque::Failure::Base
-    def self.configure(&block)
-      add_failure_backend
-      Bugsnag.configure(&block)
-    end
-
-    def self.add_failure_backend
-      return if ::Resque::Failure.backend == self
-
-      # Ensure resque is using a "Multiple" failure backend
-      unless ::Resque::Failure.backend < ::Resque::Failure::Multiple
-        original_backend = ::Resque::Failure.backend
-        ::Resque::Failure.backend = ::Resque::Failure::Multiple
-        ::Resque::Failure.backend.classes ||= []
-        ::Resque::Failure.backend.classes << original_backend
-      end
-
-      # Add Bugsnag failure backend
-      unless ::Resque::Failure.backend.classes.include?(self)
-        ::Resque::Failure.backend.classes << self
-      end
-    end
-
-    def save
-      Bugsnag.auto_notify(exception, {:context => "#{payload['class']}@#{queue}", :payload => payload, :delivery_method => :synchronous})
-    end
-  end
-end
-
-# For backwards compatibility
-Resque::Failure::Bugsnag = Bugsnag::Resque
-
-# Auto-load the failure backend
-Bugsnag::Resque.add_failure_backend
-
-Bugsnag.configuration.app_type = "resque"

data/lib/bugsnag/sidekiq.rb

@@ -1,42 +0,0 @@
-require 'sidekiq'
-
-module Bugsnag
-  class Sidekiq
-    def call(worker, msg, queue)
-      begin
-
-        # store msg/queue in thread local state to be read by Bugsnag::Middleware::Sidekiq
-        Bugsnag.set_request_data :sidekiq, { :msg => msg, :queue => queue }
-
-        yield
-      rescue Exception => ex
-        raise ex if [Interrupt, SystemExit, SignalException].include? ex.class
-        Bugsnag.auto_notify(ex)
-        raise
-      ensure
-        Bugsnag.clear_request_data
-      end
-    end
-  end
-end
-
-if ::Sidekiq::VERSION < '3'
-  ::Sidekiq.configure_server do |config|
-    config.server_middleware do |chain|
-      chain.add ::Bugsnag::Sidekiq
-    end
-  end
-else
-  ::Sidekiq.configure_server do |config|
-    config.error_handlers << lambda do |ex, ctx|
-      Bugsnag.auto_notify(ex, :sidekiq => ctx, :context => "#{ctx['class']}@#{ctx['queue']}")
-    end
-  end
-end
-
-Bugsnag.configuration.internal_middleware.use(Bugsnag::Middleware::Sidekiq)
-Bugsnag.configuration.app_type = "sidekiq"
-
-if defined?(::Sidekiq::CLI) && defined?(Bugsnag::Railtie)
-  Bugsnag::Railtie.running_as_dependency = true
-end

data/lib/bugsnag/tasks/bugsnag.cap

@@ -1,48 +0,0 @@
-namespace :load do
-
-  task :defaults do
-
-    set :bugsnag_default_hooks, ->{ true }
-
-  end
-
-end
-
-namespace :deploy do
-
-  before :starting, :bugsnag_hooks do
-    invoke 'bugsnag:add_default_hooks' if fetch(:bugsnag_default_hooks)
-  end
-
-end
-
-namespace :bugsnag do
-
-  task :add_default_hooks do
-    after 'deploy:published', 'bugsnag:deploy'
-  end
-
-  desc 'Notify Bugsnag that new production code has been deployed'
-  task :deploy do
-    run_locally do
-      begin
-        Bugsnag::Deploy.notify({
-          :api_key => fetch(:bugsnag_api_key, ENV["BUGSNAG_API_KEY"]),
-          :release_stage => fetch(:bugsnag_env) || fetch(:rails_env) || fetch(:stage) || ENV["BUGSNAG_RELEASE_STAGE"] || "production",
-          :revision => fetch(:current_revision, ENV["BUGSNAG_REVISION"]),
-          :repository => fetch(:repo_url, ENV["BUGSNAG_REPOSITORY"]),
-          :branch => fetch(:branch, ENV["BUGSNAG_BRANCH"]),
-          :app_version => fetch(:app_version, ENV["BUGSNAG_APP_VERSION"]),
-          :endpoint => fetch(:bugsnag_endpoint, Bugsnag::Configuration::DEFAULT_ENDPOINT),
-          :use_ssl => fetch(:bugsnag_use_ssl, true)
-        })
-      rescue
-        error "Bugsnag deploy notification failed, #{$!.inspect}"
-      end
-
-      info 'Bugsnag deploy notification complete.'
-    end
-  end
-
-end
-# vi:ft=ruby

data/rails/init.rb

@@ -1,7 +0,0 @@
-# On Rails 2.x GEM_ROOT/rails/init.rb is auto loaded for all gems
-# so this is the place to initialize Rails 2.x plugin support
-if Gem::Version.new(ActiveRecord::VERSION::STRING) < Gem::Version.new("3.0")
-  require "bugsnag/rails"
-else
-  Bugsnag.warn "Blocked attempt to initialize legacy Rails 2.x extensions"
-end

data/spec/cleaner_spec.rb

@@ -1,138 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe Bugsnag::Cleaner do
-  subject { described_class.new(nil) }
-
-  describe "#clean_object" do
-    it "cleans up recursive hashes" do
-      a = {:a => {}}
-      a[:a][:b] = a
-      expect(subject.clean_object(a)).to eq({:a => {:b => "[RECURSION]"}})
-    end
-
-    it "cleans up recursive arrays" do
-      a = []
-      a << a
-      a << "hello"
-      expect(subject.clean_object(a)).to eq(["[RECURSION]", "hello"])
-    end
-
-    it "allows multiple copies of the same string" do
-      a = {:name => "bugsnag"}
-      a[:second] = a[:name]
-      expect(subject.clean_object(a)).to eq({:name => "bugsnag", :second => "bugsnag"})
-    end
-
-    it "allows multiple copies of the same object" do
-      a = []
-      b = ["hello"]
-      a << b; a << b
-      expect(subject.clean_object(a)).to eq([["hello"], ["hello"]])
-    end
-
-    it "cleans up UTF8 strings properly" do
-      obj = "André"
-      expect(subject.clean_object(obj)).to eq("André")
-    end
-
-    it "cleans up binary strings properly" do
-      if RUBY_VERSION > "1.9"
-        obj = "Andr\xc7\xff"
-        if obj.respond_to? :force_encoding
-          obj = obj.force_encoding('BINARY')
-        end
-        expect(subject.clean_object(obj)).to eq("Andr��")
-      end
-    end
-
-    it "cleans up strings returned from #to_s properly" do
-      if RUBY_VERSION > "1.9"
-        str = "Andr\xc7\xff"
-        if str.respond_to? :force_encoding
-          str = str.force_encoding('BINARY')
-        end
-        obj = RuntimeError.new(str)
-        expect(subject.clean_object(obj)).to eq("Andr��")
-      end
-    end
-
-    it "filters by string inclusion" do
-      expect(described_class.new(['f']).clean_object({ :foo => 'bar' })).to eq({ :foo => '[FILTERED]' })
-      expect(described_class.new(['b']).clean_object({ :foo => 'bar' })).to eq({ :foo => 'bar' })
-    end
-
-    it "filters by regular expression" do
-      expect(described_class.new([/fb?/]).clean_object({ :foo => 'bar' })).to eq({ :foo => '[FILTERED]' })
-      expect(described_class.new([/fb+/]).clean_object({ :foo => 'bar' })).to eq({ :foo => 'bar' })
-    end
-
-    it "filters deeply nested keys" do
-      params = {:foo => {:bar => "baz"}}
-      expect(described_class.new([/^foo\.bar/]).clean_object(params)).to eq({:foo => {:bar => '[FILTERED]'}})
-    end
-
-    it "filters deeply nested request parameters" do
-      params = {:request => {:params => {:foo => {:bar => "baz"}}}}
-      expect(described_class.new([/^foo\.bar/]).clean_object(params)).to eq({:request => {:params => {:foo => {:bar => '[FILTERED]'}}}})
-    end
-  end
-
-  describe "#clean_url" do
-    let(:filters) { [] }
-    subject { described_class.new(filters).clean_url(url) }
-
-    context "with no filters configured" do
-      let(:url) { "/dir/page?param1=value1&param2=value2" }
-      it { should eq "/dir/page?param1=value1&param2=value2" }
-    end
-
-    context "with no get params" do
-      let(:url) { "/dir/page" }
-      it { should eq "/dir/page" }
-    end
-
-    context "with no matching parameters" do
-      let(:filters) { ["param3"] }
-      let(:url) { "/dir/page?param1=value1&param2=value2" }
-      it { should eq "/dir/page?param1=value1&param2=value2" }
-    end
-
-    context "with a single matching parameter" do
-      let(:filters) { ["param1"] }
-      let(:url) { "/dir/page?param1=value1&param2=value2" }
-      it { should eq "/dir/page?param1=[FILTERED]&param2=value2" }
-    end
-
-    context "with partially matching parameters" do
-      let(:filters) { ["param"] }
-      let(:url) { "/dir/page?param1=value1&param2=value2&bla=yes" }
-      it { should eq "/dir/page?param1=[FILTERED]&param2=[FILTERED]&bla=yes" }
-    end
-
-    context "with multiple matching filters" do
-      let(:filters) { ["param1", "param2"] }
-      let(:url) { "/dir/page?param1=value1&param2=value2&param3=value3" }
-      it { should eq "/dir/page?param1=[FILTERED]&param2=[FILTERED]&param3=value3" }
-    end
-
-    context "with both string and regexp filters" do
-      let(:filters) { ["param1", /param2/] }
-      let(:url) { "/dir/page?param1=value1&param2=value2&param3=value3" }
-      it { should eq "/dir/page?param1=[FILTERED]&param2=[FILTERED]&param3=value3" }
-    end
-
-    context "with matching regexp filters" do
-      let(:filters) { [/\Aaccess_token\z/] }
-      let(:url) { "https://host.example/sessions?access_token=abc123" }
-      it { should eq "https://host.example/sessions?access_token=[FILTERED]" }
-    end
-
-    context "with partially-matching regexp filters" do
-      let(:filters) { [/token/] }
-      let(:url) { "https://host.example/sessions?access_token=abc123" }
-      it { should eq "https://host.example/sessions?access_token=[FILTERED]" }
-    end
-  end
-end

data/spec/code_spec.rb

@@ -1,86 +0,0 @@
-require 'spec_helper'
-
-describe Bugsnag::Notification do
-  it "includes code in the stack trace" do
-    _a = 1
-    _b = 2
-    _c = 3
-    notify_test_exception
-    _d = 4
-    _e = 5
-    _f = 6
-
-    expect(Bugsnag).to have_sent_notification{ |payload|
-      exception = get_exception_from_payload(payload)
-      starting_line = __LINE__ - 10
-      expect(exception["stacktrace"][1]["code"]).to eq({
-        (starting_line + 0).to_s => "    _a = 1",
-        (starting_line + 1).to_s => "    _b = 2",
-        (starting_line + 2).to_s => "    _c = 3",
-        (starting_line + 3).to_s => "    notify_test_exception",
-        (starting_line + 4).to_s => "    _d = 4",
-        (starting_line + 5).to_s => "    _e = 5",
-        (starting_line + 6).to_s => "    _f = 6"
-        })
-    }
-  end
-
-  it "allows you to disable sending code" do
-    Bugsnag.configuration.send_code = false
-
-    notify_test_exception
-
-    expect(Bugsnag).to have_sent_notification{ |payload|
-      exception = get_exception_from_payload(payload)
-      expect(exception["stacktrace"][1]["code"]).to eq(nil)
-    }
-  end
-
-  it 'should send the first 7 lines of the file for exceptions near the top' do
-    load 'spec/fixtures/crashes/start_of_file.rb' rescue Bugsnag.notify $!
-
-    expect(Bugsnag).to have_sent_notification{ |payload|
-      exception = get_exception_from_payload(payload)
-
-      expect(exception["stacktrace"][0]["code"]).to eq({
-        "1" => "#",
-        "2" => "raise 'hell'",
-        "3" => "#",
-        "4" => "#",
-        "5" => "#",
-        "6" => "#",
-        "7" => "#"
-      })
-    }
-  end
-
-  it 'should send the last 7 lines of the file for exceptions near the bottom' do
-    load 'spec/fixtures/crashes/end_of_file.rb' rescue Bugsnag.notify $!
-
-    expect(Bugsnag).to have_sent_notification{ |payload|
-      exception = get_exception_from_payload(payload)
-
-      expect(exception["stacktrace"][0]["code"]).to eq({
-        "3" => "#",
-        "4" => "#",
-        "5" => "#",
-        "6" => "#",
-        "7" => "#",
-        "8" => "raise 'hell'",
-        "9" => "#"
-      })
-    }
-  end
-
-  it 'should send the last 7 lines of the file for exceptions near the bottom' do
-    load 'spec/fixtures/crashes/short_file.rb' rescue Bugsnag.notify $!
-
-    expect(Bugsnag).to have_sent_notification{ |payload|
-      exception = get_exception_from_payload(payload)
-
-      expect(exception["stacktrace"][0]["code"]).to eq({
-        "1" => "raise 'hell'"
-      })
-    }
-  end
-end

data/spec/fixtures/crashes/end_of_file.rb

@@ -1,9 +0,0 @@
-#
-#
-#
-#
-#
-#
-#
-raise 'hell'
-#

data/spec/fixtures/crashes/short_file.rb

@@ -1 +0,0 @@
-raise 'hell'

data/spec/fixtures/crashes/start_of_file.rb

@@ -1,9 +0,0 @@
-#
-raise 'hell'
-#
-#
-#
-#
-#
-#
-#

data/spec/fixtures/middleware/internal_info_setter.rb

@@ -1,11 +0,0 @@
-class InternalInfoSetter
-  MESSAGE = "set by internal_middleware"
-  def initialize(bugsnag)
-    @bugsnag = bugsnag
-  end
-
-  def call(notification)
-    notification.meta_data[:custom][:info] = MESSAGE
-    @bugsnag.call(notification)
-  end
-end

data/spec/fixtures/middleware/public_info_setter.rb

@@ -1,11 +0,0 @@
-class PublicInfoSetter
-  MESSAGE = "set by middleware"
-  def initialize(bugsnag)
-    @bugsnag = bugsnag
-  end
-
-  def call(notification)
-    notification.meta_data[:custom][:info] = MESSAGE
-    @bugsnag.call(notification)
-  end
-end

data/spec/fixtures/tasks/Rakefile

@@ -1,15 +0,0 @@
-require "bugsnag/rake"
-
-namespace :test do
-  desc "used by integration_spec to test that Bugsnag::Middleware::Rake runs properly"
-  task :crash do
-    port = ENV['BUGSNAG_TEST_SERVER_PORT']
-    Bugsnag.configure do |config|
-      config.endpoint = "localhost:#{port}"
-      config.api_key = "0" * 32
-      config.use_ssl = false
-    end
-
-    raise
-  end
-end