bugsnag 6.6.1 → 6.6.2

checksums.yaml

@@ -1,15 +1,7 @@
 ---
-!binary "U0hBMQ==":
-  metadata.gz: !binary |-
-    MjQ4Mzc4NzY4ODFiOTQ0ZDYwYzYzZDM0ZTM2OTA4OWQzYzBlYWYxMQ==
-  data.tar.gz: !binary |-
-    N2VkNzg2NjU3M2JmZTFiODQxNGU5ZWRlM2M0YWMwZDZhNTE2MTA2Mg==
+SHA1:
+  metadata.gz: d83da080bb2c9c30226d977461f97cde798d8d07
+  data.tar.gz: 0e26f87e689d5ca4793d0af232f2dc8cf18c00f9
 SHA512:
-  metadata.gz: !binary |-
-    NGMyYzc4MGNmZGNjZmMwYTFhNDZkZWEwOGZkYmUxYTUxNDRkYzU0NjIzMTI4
-    ZjMyYzFlY2IxZTUxZDg0NzBlNmIwZGI1MzAxZjA3NTI0NWViMGE5YmFkNDQ3
-    ZWQ0YTYwNGEzOWExNDZjYjQxOTA0ZWI0MGQ2MDQ2NTAzZWYwMmI=
-  data.tar.gz: !binary |-
-    ZWJmNjRjODM0MzEwNDQ0YWQzY2IxNjdkNTM1OGUwZTk1YjJlMTY1ZDRkN2Fl
-    YmI0YWUzZGNiM2QyNmZmOGNhMzA0NGI4YjVjZDg3MmNlNTgwNzljM2NjZDM0
-    NmEwZDgwNzIwYTZiNzMxZGM2MzUxMzExMjI5NDVmZjYzMzg0M2E=
+  metadata.gz: 57e35aeba57e4a7620f3f66ae52f2f2100c9ee548c54b5af04298511e8d808fd25be1b61cd916e15306fb18b3e26ddd3b9edb8774132095ca70b4740b713b268
+  data.tar.gz: 2caa6ce50271d9928d1bdecc57142e8b3f065596799dbdb3f5c33ec63f1efd231aede5afd9f047c849314cb9326e4ad2c14ce07c7573e49a00bbdb0eefcff9e8

data/CHANGELOG.md

@@ -1,7 +1,13 @@
 Changelog
 =========
 
-## 6.6.0 (09 Jan 2018)
+## 6.6.2 (18 Jan 2018)
+
+* Fix Shoryuken integration & `project_root` `Pathname` issue
+  | [#416](https://github.com/bugsnag/bugsnag-ruby/pull/416)
+  | [Sergei Maximov](https://github.com/smaximov)
+
+## 6.6.1 (09 Jan 2018)
 
 ### Bug fixes
 

data/VERSION

@@ -1 +1 @@
-6.6.1
+6.6.2

data/lib/bugsnag/integrations/shoryuken.rb

@@ -26,7 +26,7 @@ module Bugsnag
         yield
       rescue Exception => ex
         unless [Interrupt, SystemExit, SignalException].include?(ex.class)
-          Bugsnag.auto_notify(ex, true) do |report|
+          Bugsnag.notify(ex, true) do |report|
             report.severity = "error"
             report.severity_reason = {
               :type => Bugsnag::Report::UNHANDLED_EXCEPTION_MIDDLEWARE,
@@ -46,4 +46,4 @@ end
   config.server_middleware do |chain|
     chain.add ::Bugsnag::Shoryuken
   end
-end
+end

data/lib/bugsnag/stacktrace.rb

@@ -42,7 +42,7 @@ module Bugsnag
 
         # Clean up the file path in the stacktrace
         if defined?(@configuration.project_root) && @configuration.project_root.to_s != ''
-          trace_hash[:inProject] = true if file.start_with?(@configuration.project_root)
+          trace_hash[:inProject] = true if file.start_with?(@configuration.project_root.to_s)
           file.sub!(/#{@configuration.project_root}\//, "")
           trace_hash.delete(:inProject) if file.start_with?(VENDOR_PATH)
         end

data/spec/integration_spec.rb

@@ -23,21 +23,6 @@ describe 'Bugsnag' do
 
   let(:request) { JSON.parse(queue.pop) }
 
-  it 'should run the rake middleware when rake tasks crash' do
-    #Skips this test in ruby 1.9.3 with travis
-    unless ENV['TRAVIS'] && RUBY_VERSION == "1.9.3"
-      ENV['BUGSNAG_TEST_SERVER_PORT'] = server.config[:Port].to_s
-      task_fixtures_path = File.join(File.dirname(__FILE__), 'fixtures', 'tasks')
-      Dir.chdir(task_fixtures_path) do
-        system("bundle exec rake test:crash > /dev/null 2>&1")
-      end
-
-      result = request()
-      expect(result["events"][0]["metaData"]["rake_task"]).not_to be_nil
-      expect(result["events"][0]["metaData"]["rake_task"]["name"]).to eq("test:crash")
-    end
-  end
-
   it 'should send notifications over the wire' do
     Bugsnag.configure do |config|
       config.endpoint = "http://localhost:#{server.config[:Port]}"

data/spec/integrations/clearance_user_spec.rb

@@ -0,0 +1,38 @@
+require "spec_helper"
+
+describe Bugsnag::Middleware::ClearanceUser do
+  it "updates the reports user with warden parameters" do
+    callback = double
+
+    user = double
+    allow(user).to receive_messages(
+      :email => "TEST_EMAIL",
+      :name => "TEST_NAME",
+      :created_at => "TEST_NOW"
+    )
+
+    clearance = double
+    allow(clearance).to receive_messages(
+      :signed_in? => true,
+      :current_user => user
+    )
+
+    report = double("Bugsnag::Report") 
+    expect(report).to receive(:request_data).exactly(5).times.and_return({
+      :rack_env => {
+        :clearance => clearance
+      }
+    })
+
+    expect(report).to receive(:user=).with({
+      :email => "TEST_EMAIL",
+      :name => "TEST_NAME",
+      :created_at => "TEST_NOW"
+    })
+
+    expect(callback).to receive(:call).with(report)
+
+    middleware = Bugsnag::Middleware::ClearanceUser.new(callback)
+    middleware.call(report)
+  end
+end

data/spec/integrations/mailman_spec.rb

@@ -0,0 +1,83 @@
+require "spec_helper"
+
+describe 'Bugsnag::Mailman', :order => :defined do
+  before do
+    unless defined?(::Mailman)
+      @mocked_mailman = true
+      class Mailman
+      end
+      module Kernel
+        alias_method :old_require, :require
+        def require(path)
+          old_require(path) unless /^mailman/.match(path)
+        end
+      end
+    end
+  end
+
+  it "should load Bugsnag::Mailman" do
+    config = double('mailman-config')
+    allow(Mailman).to receive(:config).and_return(config)
+    expect(config).to receive(:respond_to?).with(:middleware).and_return(true)
+    middleware = double('mailman-config-middleware')
+    expect(config).to receive(:middleware).and_return(middleware)
+    expect(middleware).to receive(:add).with(any_args)
+
+    #Kick off
+    require './lib/bugsnag/integrations/mailman'
+  end
+
+  it "can be called" do
+    config = double('config')
+    allow(Bugsnag).to receive(:configuration).and_return(config)
+    int_middleware = double('internal_middleware')
+    expect(config).to receive(:internal_middleware).and_return(int_middleware)
+    expect(int_middleware).to receive(:use).with(Bugsnag::Middleware::Mailman)
+    expect(config).to receive(:app_type=).with("mailman")
+
+    integration = Bugsnag::Mailman.new
+
+    mail = double('mail')
+    expect(config).to receive(:set_request_data).with(:mailman_msg, mail)
+    expect(mail).to receive(:to_s).and_return(mail)
+    allow(config).to receive(:clear_request_data)
+
+    exception = RuntimeError.new('oops')
+    report = double('report')
+    expect(Bugsnag).to receive(:notify).with(exception, true).and_yield(report)
+    expect(report).to receive(:severity=).with('error')
+    expect(report).to receive(:severity_reason=).with({
+      :type => Bugsnag::Report::UNHANDLED_EXCEPTION_MIDDLEWARE,
+      :attributes => Bugsnag::Mailman::FRAMEWORK_ATTRIBUTES
+    })
+    expect{integration.call(mail) {raise exception}}.to raise_error(exception)
+  end
+
+  after do
+    Object.send(:remove_const, :Mailman) if @mocked_mailman
+    module Kernel
+      alias_method :require, :old_require
+    end
+  end
+end
+
+
+describe Bugsnag::Middleware::Mailman do
+  it "adds mailman message to the metadata" do
+    callback = double
+
+    report = double("Bugsnag::Report")
+    expect(report).to receive(:request_data).and_return({
+      :mailman_msg => "test message"
+    })
+
+    expect(report).to receive(:add_tab).with(:mailman, {
+      "message" => "test message"
+    })
+
+    expect(callback).to receive(:call).with(report)
+
+    middleware = Bugsnag::Middleware::Mailman.new(callback)
+    middleware.call(report)
+  end
+end

data/spec/integrations/que_spec.rb

@@ -0,0 +1,60 @@
+# encoding: utf-8
+require 'spec_helper'
+
+describe 'Bugsnag::Que', :order => :defined do
+  before do
+    unless defined?(::Que)
+      @mocked_que = true
+      class ::Que
+      end
+    end
+  end
+
+  it "should create and register a que handler" do
+    error = RuntimeError.new("oops")
+    job = double('que_job')
+    expect(job).to receive(:dup).and_return({
+      :error_count => 0,
+      :job_class => 'ActiveJob::QueueAdapters::QueAdapter::JobWrapper',
+      :args => [{"queue_name" => "foo", "arguments" => "bar"}],
+      :job_id => "ID"
+    })
+
+    report = double('report')
+    expect(Bugsnag).to receive(:notify).with(error, true).and_yield(report)
+    expect(report).to receive(:add_tab).with(:job, {
+      :error_count => 1,
+      :job_class => 'ActiveJob::QueueAdapters::QueAdapter::JobWrapper',
+      :args => [{"queue_name" => "foo", "arguments" => "bar"}],
+      :job_id => "ID",
+      :wrapper_job_class => 'ActiveJob::QueueAdapters::QueAdapter::JobWrapper',
+      :wrapper_job_id => "ID",
+      :queue => "foo",
+      :args => "bar"
+    })
+    expect(report).to receive(:severity=).with("error")
+    expect(report).to receive(:severity_reason=).with({
+      :type => Bugsnag::Report::UNHANDLED_EXCEPTION_MIDDLEWARE,
+      :attributes => {
+        :framework => 'Que'
+      }
+    })
+
+    allow(Que).to receive(:respond_to?).with(:error_notifier=).and_return(true)
+    config = double('config')
+    allow(Bugsnag).to receive(:configuration).and_return(config)
+    expect(config).to receive(:app_type)
+    expect(config).to receive(:app_type=).with('que')
+    allow(config).to receive(:clear_request_data)
+    expect(Que).to receive(:error_notifier=) do |handler|
+      handler.call(error, job)
+    end
+
+    #Kick off
+    load './lib/bugsnag/integrations/que.rb'
+  end
+
+  after do
+    Object.send(:remove_const, :Que) if @mocked_que
+  end
+end

data/spec/integrations/rack_spec.rb

@@ -0,0 +1,147 @@
+require 'spec_helper'
+
+describe Bugsnag::Rack do
+  it "calls the upstream rack app with the environment" do
+    rack_env = {"key" => "value"}
+    app = lambda { |env| ['response', {}, env] }
+    rack_stack = Bugsnag::Rack.new(app)
+
+    response = rack_stack.call(rack_env)
+
+    expect(response).to eq(['response', {}, rack_env])
+  end
+
+  context "when an exception is raised in rack middleware" do
+    # Build a fake crashing rack app
+    exception = BugsnagTestException.new("It crashed")
+    rack_env = {"key" => "value"}
+    app = lambda { |env| raise exception }
+    rack_stack = Bugsnag::Rack.new(app)
+
+    it "re-raises the exception" do
+      expect { rack_stack.call(rack_env) }.to raise_error(BugsnagTestException)
+    end
+
+    it "delivers an exception if auto_notify is enabled" do
+      rack_stack.call(rack_env) rescue nil
+
+      expect(Bugsnag).to have_sent_notification{ |payload, headers|
+        exception_class = payload["events"].first["exceptions"].first["errorClass"]
+        expect(exception_class).to eq(exception.class.to_s)
+      }
+
+    end
+
+    it "applies the correct severity reason" do
+      rack_stack.call(rack_env) rescue nil
+
+      expect(Bugsnag).to have_sent_notification{ |payload, headers|
+        event = get_event_from_payload(payload)
+        expect(event["unhandled"]).to be true
+        expect(event["severityReason"]).to eq({
+          "type" => "unhandledExceptionMiddleware",
+          "attributes" => {
+            "framework" => "Rack"
+          }
+        })
+      }
+    end
+
+    it "does not deliver an exception if auto_notify is disabled" do
+      Bugsnag.configure do |config|
+        config.auto_notify = false
+      end
+
+      rack_stack.call(rack_env) rescue nil
+
+      expect(Bugsnag).not_to have_sent_notification
+    end
+  end
+
+  context "when running against the middleware" do
+    before do
+      unless defined?(::Rack)
+        @mocked_rack = true
+        class ::Rack
+          class ::Request
+          end
+        end
+      end
+    end
+
+    it "correctly extracts data from rack middleware" do
+      callback = double
+      rack_env = {
+        :env => true,
+        :HTTP_test_key => "test_key",
+        "rack.session" => {
+          :session => true
+        }
+      }
+      
+      rack_request = double
+      rack_params = {
+        :param => 'test'
+      }
+      allow(rack_request).to receive_messages(
+        :params => rack_params,
+        :ip => "rack_ip",
+        :request_method => "TEST",
+        :path => "/TEST_PATH",
+        :scheme => "http",
+        :host => "test_host",
+        :port => 80,
+        :referer => "referer",
+        :fullpath => "/TEST_PATH"
+      )
+      expect(::Rack::Request).to receive(:new).with(rack_env).and_return(rack_request)
+
+      report = double("Bugsnag::Report")
+      allow(report).to receive(:request_data).and_return({
+        :rack_env => rack_env
+      })
+      expect(report).to receive(:context=).with("TEST /TEST_PATH")
+      expect(report).to receive(:user).and_return({})
+
+      config = double
+      allow(config).to receive(:send_environment).and_return(true)
+      allow(config).to receive(:meta_data_filters).and_return(nil)
+      allow(report).to receive(:configuration).and_return(config)
+      expect(report).to receive(:add_tab).once.with(:environment, rack_env)
+      expect(report).to receive(:add_tab).once.with(:request, {
+        :url => "http://test_host/TEST_PATH",
+        :httpMethod => "TEST",
+        :params => rack_params,
+        :referer => "referer",
+        :clientIp => "rack_ip",
+        :headers => {
+          "Test-Key" => "test_key"
+        }
+      })
+      expect(report).to receive(:add_tab).once.with(:session, {
+        :session => true
+      })
+
+      expect(callback).to receive(:call).with(report)
+
+      middleware = Bugsnag::Middleware::RackRequest.new(callback)
+      middleware.call(report)
+    end
+
+    after do
+      Object.send(:remove_const, :Rack) if @mocked_rack
+    end
+
+  end
+
+  it "don't mess with middlewares list on each req" do
+    stub_const('Rack', nil)
+    app = lambda { |env| ['200', {}, ['']] }
+
+    Bugsnag::Rack.new(app)
+
+    expect { 2.times { Bugsnag::Rack.new(app) } }.not_to change {
+      Bugsnag.configuration.middleware.instance_variable_get(:@middlewares)
+    }
+  end
+end

data/spec/{rails3_request_spec.rb → integrations/rails3_request_spec.rb}

@@ -23,6 +23,21 @@ describe Bugsnag::Middleware::Rails3Request do
       }
     end
 
+    it "unsets request metadata" do
+      Bugsnag.configuration.set_request_data(:rack_env, {
+        "action_dispatch.remote_ip" => "10.2.2.224",
+        "action_dispatch.request_id" => "5",
+      })
+      Bugsnag.configuration.unset_request_data(:rack_env, nil)
+      Bugsnag.notify(BugsnagTestException.new('Grimbles'))
+
+      expect(Bugsnag).to have_sent_notification { |payload, headers|
+        event = get_event_from_payload(payload)
+        puts event["metaData"].inspect
+        expect(event["metaData"]["request"]).to be nil
+      }
+    end
+
     context "the Remote IP will throw when serialized" do
 
       it "sets the client IP metdata to [SPOOF]" do

data/spec/integrations/rake_spec.rb

@@ -0,0 +1,72 @@
+require 'webrick'
+require 'spec_helper'
+require 'json'
+
+describe "Bugsnag Rake integration" do
+  describe Bugsnag::Middleware::Rake do
+    it "adds rake data to the report" do
+      callback = double
+
+      task = double
+      allow(task).to receive_messages(
+        :name => "TEST_NAME",
+        :full_comment => "TEST_COMMENT",
+        :arg_description =>"TEST_ARGS"
+      )
+
+      report = double("Bugsnag::Report") 
+      expect(report).to receive(:request_data).and_return({
+        :bugsnag_running_task => task
+      })
+      expect(report).to receive(:add_tab).with(:rake_task, {
+        :name => "TEST_NAME",
+        :description => "TEST_COMMENT",
+        :arguments => "TEST_ARGS"
+      })
+      expect(report).to receive(:context).with(no_args)
+      expect(report).to receive(:context=).with("TEST_NAME")
+
+      expect(callback).to receive(:call).with(report)
+
+      middleware = Bugsnag::Middleware::Rake.new(callback)
+      middleware.call(report)
+    end
+  end
+
+  describe "Bugsnag::Rake" do
+    server = nil
+    queue = Queue.new
+
+    before do
+      server = WEBrick::HTTPServer.new :Port => 0, :Logger => WEBrick::Log.new("/dev/null"), :AccessLog => []
+      server.mount_proc '/' do |req, res|
+        queue.push req.body
+        res.status = 200
+        res.body = "OK\n"
+      end
+      Thread.new{ server.start }
+    end
+
+    after do
+      server.stop
+      queue.clear
+    end
+
+    let(:request) { JSON.parse(queue.pop) }
+
+    it 'should run the rake middleware when rake tasks crash' do
+      #Skips this test in ruby 1.9.3 with travis
+      unless ENV['TRAVIS'] && RUBY_VERSION == "1.9.3"
+        ENV['BUGSNAG_TEST_SERVER_PORT'] = server.config[:Port].to_s
+        task_fixtures_path = File.join(File.dirname(__FILE__), '../fixtures', 'tasks')
+        Dir.chdir(task_fixtures_path) do
+          system("bundle exec rake test:crash > /dev/null 2>&1")
+        end
+
+        result = request()
+        expect(result["events"][0]["metaData"]["rake_task"]).not_to be_nil
+        expect(result["events"][0]["metaData"]["rake_task"]["name"]).to eq("test:crash")
+      end
+    end
+  end
+end

data/spec/integrations/resque_spec.rb

@@ -0,0 +1,92 @@
+# encoding: utf-8
+require 'spec_helper'
+
+describe 'Bugsnag::Resque', :order => :defined do
+  before do
+    unless defined?(::Resque)
+      @mocked_resque = true
+      class ::Resque
+        class Worker
+        end
+        class Failure
+          class Bugsnag
+          end
+          class Base
+          end
+          class Multiple
+          end
+        end
+      end
+      module Kernel
+        alias_method :old_require, :require
+        def require(path)
+          old_require(path) unless /^resque/.match(path)
+        end
+      end
+    end
+  end
+
+  it "should load Bugsnag::Resque" do
+    #Auto-load failure backend
+    backend = double('backend')
+    allow(::Resque::Failure).to receive(:backend).and_return(backend)
+    expect(backend).to receive(:<).and_return(nil)
+    expect(::Resque::Failure).to receive(:backend=).with(::Resque::Failure::Multiple)
+    classes = double('classes')
+    allow(backend).to receive(:classes).and_return(classes)
+    expect(classes).to receive(:<<).with(backend)
+    expect(classes).to receive(:include?).and_return(false)
+    expect(classes).to receive(:<<)
+
+    #Bugsnag fork check
+    fork_check = double("fork_check")
+    expect(::Resque::Worker).to receive(:new).with(:bugsnag_fork_check).and_return(fork_check)
+    expect(fork_check).to receive(:fork_per_job?).and_return(true)
+    expect(::Resque).to receive(:after_fork).and_yield
+    expect(Bugsnag.configuration).to receive(:app_type=).with("resque")
+    expect(Bugsnag.configuration).to receive(:default_delivery_method=).with(:synchronous)
+
+    #Kick off
+    require './lib/bugsnag/integrations/resque'
+  end
+
+  it "can configure" do
+    expect(Bugsnag::Resque).to receive(:add_failure_backend)
+    expect(Bugsnag).to receive(:configure).and_yield
+    Bugsnag::Resque.configure do
+    end
+  end
+
+  it "can save data" do
+    resque = Bugsnag::Resque.new
+    exception = double('exception')
+    allow(resque).to receive(:exception).and_return(exception)
+    allow(resque).to receive(:payload).and_return({
+      "class" => "class"
+    })
+    allow(resque).to receive(:queue).and_return("queue")
+    report = double('report')
+    expect(report).to receive(:severity=).with("error")
+    expect(report).to receive(:severity_reason=).with({
+      :type => Bugsnag::Report::UNHANDLED_EXCEPTION_MIDDLEWARE,
+      :attributes => Bugsnag::Resque::FRAMEWORK_ATTRIBUTES
+    })
+    meta_data = double('meta_data')
+    expect(report).to receive(:meta_data).and_return(meta_data)
+    expect(meta_data).to receive(:merge!).with({
+      :context => "class@queue",
+      :payload => {
+        "class" => "class"
+      }
+    })
+    expect(Bugsnag).to receive(:notify).with(exception, true).and_yield(report)
+    resque.save
+  end
+
+  after do
+    Object.send(:remove_const, :Resque) if @mocked_resque
+    module Kernel
+      alias_method :require, :old_require
+    end
+  end
+end

data/spec/integrations/shoryuken_spec.rb

@@ -0,0 +1,70 @@
+# encoding: utf-8
+require 'spec_helper'
+
+describe 'Bugsnag::Shoryuken', :order => :defined do
+  before do
+    unless defined?(::Shoryuken)
+      @mocked_shoryuken = true
+      class ::Shoryuken
+      end
+      module Kernel
+        alias_method :old_require, :require
+        def require(path)
+          old_require(path) unless path == 'shoryuken'
+        end
+      end
+    end
+  end
+
+  it "should call configure_server" do
+    chain = double("chain")
+    expect(chain).to receive(:add).with(anything())
+    config = double("config")
+    expect(config).to receive(:server_middleware).and_yield(chain)
+    expect(::Shoryuken).to receive(:configure_server).and_yield(config)
+
+    require './lib/bugsnag/integrations/shoryuken'
+  end
+
+  it "calls configure when initialised" do
+    config = double("config")
+    
+    expect(config).to receive(:app_type).and_return(nil)
+    expect(config).to receive(:app_type=).with("shoryuken")
+    expect(config).to receive(:default_delivery_method=).with(:synchronous)
+    expect(Bugsnag).to receive(:configure).and_yield(config)
+    Bugsnag::Shoryuken.new
+  end
+
+  it "calls correct sequence when called" do
+    queue = 'queue'
+    body = 'body'
+
+    callbacks = double('callbacks')
+    expect(callbacks).to receive(:<<) do |func|
+      report = double('report')
+      expect(report).to receive(:add_tab).with(:shoryuken, {
+        queue: queue,
+        body: body
+      })
+      func.call(report)
+    end
+    config = double('config')
+    allow(config).to receive(:app_type).and_return(nil)
+    allow(config).to receive(:app_type=).with("shoryuken")
+    allow(config).to receive(:default_delivery_method=).with(:synchronous)
+    allow(config).to receive(:clear_request_data)
+    expect(Bugsnag).to receive(:before_notify_callbacks).and_return(callbacks)
+    allow(Bugsnag).to receive(:configure).and_yield(config)
+    allow(Bugsnag).to receive(:configuration).and_return(config)
+    shoryuken = Bugsnag::Shoryuken.new
+    expect { |b| shoryuken.call('_', queue, '_', body, &b )}.to yield_control
+  end
+
+  after do
+    Object.send(:remove_const, :Shoryuken) if @mocked_shoryuken
+    module Kernel
+      alias_method :require, :old_require
+    end
+  end
+end

data/spec/integrations/warden_user_spec.rb

@@ -0,0 +1,41 @@
+require "spec_helper"
+
+describe Bugsnag::Middleware::WardenUser do
+  it "updates the reports user with warden parameters" do
+    callback = double
+
+    user = double
+    allow(user).to receive_messages(
+      :email => "TEST_EMAIL",
+      :name => "TEST_NAME",
+      :created_at => "TEST_NOW"
+    )
+
+    warden = double
+    allow(warden).to receive(:user).with(
+      :scope => "user",
+      :run_callbacks => false
+    ).and_return(user)
+
+    report = double("Bugsnag::Report") 
+    expect(report).to receive(:request_data).exactly(3).times.and_return({
+      :rack_env => {
+        "warden" => warden,
+        "rack.session" => {
+          "warden.user.user.key" => "TEST_USER"
+        }
+      }
+    })
+
+    expect(report).to receive(:user=).with({
+      :email => "TEST_EMAIL",
+      :name => "TEST_NAME",
+      :created_at => "TEST_NOW"
+    })
+
+    expect(callback).to receive(:call).with(report)
+
+    middleware = Bugsnag::Middleware::WardenUser.new(callback)
+    middleware.call(report)
+  end
+end

data/spec/middleware_stack_spec.rb

@@ -0,0 +1,151 @@
+require 'spec_helper'
+
+class TestMiddleware
+  def initialize(bugsnag)
+    @bugsnag = bugsnag
+  end
+
+  def call(report)
+    @bugsnag.call(report)
+  end
+end
+
+module Bugsnag
+  class MiddlewareStack
+    attr_reader :middlewares
+    attr_reader :disabled_middleware
+  end
+end
+
+describe Bugsnag::MiddlewareStack do
+  describe "defaults" do
+    it "to empty middleware lists" do
+      expect(subject.middlewares.size).to eq(0)
+      expect(subject.disabled_middleware.size).to eq(0)
+    end
+  end
+
+  describe "use" do
+    it "allows middleware to be added to the stack" do
+      middleware = TestMiddleware.new(nil)
+      subject.use(middleware)
+      expect(subject.middlewares.size).to eq(1)
+      expect(subject.middlewares.last).to eq(middleware)
+    end
+
+    it "doesn't add middleware more than once" do
+      middleware = TestMiddleware.new(nil)
+      subject.use(middleware)
+      expect(subject.middlewares.size).to eq(1)
+      subject.use(middleware)
+      expect(subject.middlewares.size).to eq(1)
+    end
+  end
+
+  describe "disable" do
+    it "adds middleware to a disabled list" do
+      middleware = TestMiddleware.new(nil)
+      subject.disable(middleware)
+      expect(subject.disabled_middleware.size).to eq(1)
+      expect(subject.disabled_middleware.last).to eq(middleware)
+    end
+
+    it "prevents middleware from being added" do
+      middleware = TestMiddleware.new(nil)
+      subject.disable(middleware)
+      subject.use(middleware)
+      expect(subject.middlewares.size).to eq(0)
+    end
+
+    it "removes already added middleware" do
+      middleware = TestMiddleware.new(nil)
+      subject.use(middleware)
+      expect(subject.middlewares.size).to eq(1)
+      subject.disable(middleware)
+      expect(subject.middlewares.size).to eq(0)
+    end
+  end
+
+  describe "insert_before" do
+    it "inserts middleware before specified middleware" do
+      middleware_one = TestMiddleware.new(nil)
+      middleware_two = TestMiddleware.new(nil)
+      subject.use(middleware_one)
+      expect(subject.middlewares.size).to eq(1)
+      expect(subject.middlewares.first).to eq(middleware_one)
+      subject.insert_before(middleware_one, middleware_two)
+      expect(subject.middlewares.size).to eq(2)
+      expect(subject.middlewares.first).to eq(middleware_two)
+    end
+
+    it "appends middleware otherwise" do
+      middleware_one = TestMiddleware.new(nil)
+      middleware_two = TestMiddleware.new(nil)
+      subject.use(middleware_one)
+      expect(subject.middlewares.size).to eq(1)
+      expect(subject.middlewares.first).to eq(middleware_one)
+      subject.insert_before(nil, middleware_two)
+      expect(subject.middlewares.size).to eq(2)
+      expect(subject.middlewares.first).to eq(middleware_one)
+    end
+
+    it "accepts an array of middleware to insert before" do
+      middleware_one = TestMiddleware.new(nil)
+      middleware_two = TestMiddleware.new(nil)
+      middleware_three = TestMiddleware.new(nil)
+      subject.use(middleware_one)
+      subject.use(middleware_two)
+      expect(subject.middlewares.size).to eq(2)
+      expect(subject.middlewares.first).to eq(middleware_one)
+      subject.insert_before([middleware_one, middleware_two], middleware_three)
+      expect(subject.middlewares.size).to eq(3)
+      expect(subject.middlewares.first).to eq(middleware_three)
+    end
+  end
+
+  describe "insert_after" do
+    it "inserts middleware after specified middleware" do
+      middleware_one = TestMiddleware.new(nil)
+      middleware_two = TestMiddleware.new(nil)
+      subject.use(middleware_one)
+      expect(subject.middlewares.size).to eq(1)
+      expect(subject.middlewares.first).to eq(middleware_one)
+      subject.insert_after(middleware_one, middleware_two)
+      expect(subject.middlewares.size).to eq(2)
+      expect(subject.middlewares.last).to eq(middleware_two)
+    end
+
+    it "appends middleware otherwise" do
+      middleware_one = TestMiddleware.new(nil)
+      middleware_two = TestMiddleware.new(nil)
+      subject.use(middleware_one)
+      expect(subject.middlewares.size).to eq(1)
+      expect(subject.middlewares.first).to eq(middleware_one)
+      subject.insert_after(nil, middleware_two)
+      expect(subject.middlewares.size).to eq(2)
+      expect(subject.middlewares.first).to eq(middleware_one)
+    end
+
+    it "accepts an array of middleware to insert after" do
+      middleware_one = TestMiddleware.new(nil)
+      middleware_two = TestMiddleware.new(nil)
+      middleware_three = TestMiddleware.new(nil)
+      subject.use(middleware_one)
+      subject.use(middleware_two)
+      expect(subject.middlewares.size).to eq(2)
+      expect(subject.middlewares.last).to eq(middleware_two)
+      subject.insert_after([middleware_one, middleware_two], middleware_three)
+      expect(subject.middlewares.size).to eq(3)
+      expect(subject.middlewares.last).to eq(middleware_three)
+    end
+  end
+
+  describe "method_missing" do
+    it "calls send and proxies the method into the array" do
+      middleware = TestMiddleware.new(nil)
+      subject.method_missing(:<<, middleware)
+      expect(subject.middlewares.size).to eq(1)
+      expect(subject.middlewares.last).to eq(middleware)
+    end
+  end
+end

metadata

@@ -1,27 +1,27 @@
 --- !ruby/object:Gem::Specification
 name: bugsnag
 version: !ruby/object:Gem::Version
-  version: 6.6.1
+  version: 6.6.2
 platform: ruby
 authors:
 - James Smith
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-01-10 00:00:00.000000000 Z
+date: 2018-01-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: concurrent-ruby
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1.0'
 description: Ruby notifier for bugsnag.com
@@ -33,9 +33,9 @@ extra_rdoc_files:
 - README.md
 - CHANGELOG.md
 files:
-- .gitignore
-- .rspec
-- .travis.yml
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
 - CHANGELOG.md
 - CONTRIBUTING.md
 - Gemfile
@@ -97,11 +97,19 @@ files:
 - spec/fixtures/tasks/Rakefile
 - spec/helper_spec.rb
 - spec/integration_spec.rb
+- spec/integrations/clearance_user_spec.rb
 - spec/integrations/delayed_job_spec.rb
+- spec/integrations/mailman_spec.rb
+- spec/integrations/que_spec.rb
+- spec/integrations/rack_spec.rb
+- spec/integrations/rails3_request_spec.rb
+- spec/integrations/rake_spec.rb
+- spec/integrations/resque_spec.rb
+- spec/integrations/shoryuken_spec.rb
 - spec/integrations/sidekiq_spec.rb
+- spec/integrations/warden_user_spec.rb
 - spec/middleware_spec.rb
-- spec/rack_spec.rb
-- spec/rails3_request_spec.rb
+- spec/middleware_stack_spec.rb
 - spec/report_spec.rb
 - spec/session_tracker_spec.rb
 - spec/spec_helper.rb
@@ -116,17 +124,17 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: 1.9.2
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.12
+rubygems_version: 2.6.13
 signing_key: 
 specification_version: 4
 summary: Ruby notifier for bugsnag.com

data/spec/rack_spec.rb

@@ -1,71 +0,0 @@
-require 'spec_helper'
-
-describe Bugsnag::Rack do
-  it "calls the upstream rack app with the environment" do
-    rack_env = {"key" => "value"}
-    app = lambda { |env| ['response', {}, env] }
-    rack_stack = Bugsnag::Rack.new(app)
-
-    response = rack_stack.call(rack_env)
-
-    expect(response).to eq(['response', {}, rack_env])
-  end
-
-  context "when an exception is raised in rack middleware" do
-    # Build a fake crashing rack app
-    exception = BugsnagTestException.new("It crashed")
-    rack_env = {"key" => "value"}
-    app = lambda { |env| raise exception }
-    rack_stack = Bugsnag::Rack.new(app)
-
-    it "re-raises the exception" do
-      expect { rack_stack.call(rack_env) }.to raise_error(BugsnagTestException)
-    end
-
-    it "delivers an exception if auto_notify is enabled" do
-      rack_stack.call(rack_env) rescue nil
-
-      expect(Bugsnag).to have_sent_notification{ |payload, headers|
-        exception_class = payload["events"].first["exceptions"].first["errorClass"]
-        expect(exception_class).to eq(exception.class.to_s)
-      }
-
-    end
-
-    it "applies the correct severity reason" do
-      rack_stack.call(rack_env) rescue nil
-
-      expect(Bugsnag).to have_sent_notification{ |payload, headers|
-        event = get_event_from_payload(payload)
-        expect(event["unhandled"]).to be true
-        expect(event["severityReason"]).to eq({
-          "type" => "unhandledExceptionMiddleware",
-          "attributes" => {
-            "framework" => "Rack"
-          }
-        })
-      }
-    end
-
-    it "does not deliver an exception if auto_notify is disabled" do
-      Bugsnag.configure do |config|
-        config.auto_notify = false
-      end
-
-      rack_stack.call(rack_env) rescue nil
-
-      expect(Bugsnag).not_to have_sent_notification
-    end
-  end
-
-  it "don't mess with middlewares list on each req" do
-    stub_const('Rack', nil)
-    app = lambda { |env| ['200', {}, ['']] }
-
-    Bugsnag::Rack.new(app)
-
-    expect { 2.times { Bugsnag::Rack.new(app) } }.not_to change {
-      Bugsnag.configuration.middleware.instance_variable_get(:@middlewares)
-    }
-  end
-end