bugsnag 2.8.13 → 3.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7d6aa2d47b176056a2296c83ed021e60535d8500
-  data.tar.gz: 993b3197a9a58242cc35f27ee6e89144c0a5bc56
+  metadata.gz: c47737bc08fe70bfdc4b9391ab04d5b6aa6900aa
+  data.tar.gz: abe70b3cc901bf48a06fab50bd410e1927ca7a6d
 SHA512:
-  metadata.gz: 42e61fc1a225f0428fe20357d0af38f022e9fecd835b0c414651f2873e26f00165beee2059920002185db91e082896fa225b68024bad6b74d5d6c20452c2eb46
-  data.tar.gz: 4d55d3468985cc4a7b6b7b2275b26af66ae0b39d200b2063a9db687990e67f927d2fd663034484dfe4db6fb898f3ec66009c2eba1624846d68b590c6ae86fecf
+  metadata.gz: eedb7804e481f0ecfd3436b758e7880f7ebfe232cc7fc93ee5a670738e61df4751a7ff11523cd523c9ec873259f21880df84d214f2a63333c3f6bda704c34184
+  data.tar.gz: afc1a1885938f4926dea26e9eb4f22080ea506f15997afe4acd4302085a445e5ff7a0e7191c2d55f50f2919a8a56c664ea7e64b261d6c4c76d360ed823d5da23

data/.travis.yml

@@ -1,3 +1,4 @@
+sudo: false
 language: ruby
 rvm:
 - 2.1.0
@@ -9,7 +10,3 @@ rvm:
 before_install:
 - gem update --system 2.1.11
 - gem --version
-notifications:
-  hipchat:
-    rooms:
-      secure: cv5V8ivZExOywKL9n0CODnxy9m5u4rQ5ZMYK8XHPIoqQKkvH9DQOeb2ItW2aM2kxeupJEcQEy1Eu4sYMGhyzKUNdqbFtQBhDYxRwSAgTRIkGlHQCnznyExHWZbGfDB8y/m11HiZ1wuPuqs8ZZ+VccNb4bwJKbhPTbf1RZ+GPeU8=

data/CHANGELOG.md

@@ -1,6 +1,23 @@
 Changelog
 =========
 
+3.0.0 (23 Dec 2015)
+-----
+
+### Enhancements
+
+* Fix warning from usage of `before_filter` in Rails 5
+  | [Scott Ringwelski](https://github.com/sgringwe)
+  | [#267](https://github.com/bugsnag/bugsnag-ruby/pull/267)
+
+* Use Rails 5-style deep parameter filtering
+  | [fimmtiu](https://github.com/fimmtiu)
+  | [#256](https://github.com/bugsnag/bugsnag-ruby/pull/256)
+
+  Note: This is a backwards incompatible change, as filters containing `.` are
+  now parsed as nested instead of as a single key.
+
+
 2.8.13
 ------
 

data/README.md

@@ -24,16 +24,13 @@ Contents
 	- [Sending Non-fatal Exceptions](#sending-non-fatal-exceptions)
 	- [Deploy Tracking](#deploy-tracking)
 	- [Callbacks](#callbacks)
+	- [Configuration](https://github.com/bugsnag/bugsnag-ruby/tree/master/docs/Configuration.md)
+	- [Notification Options](https://github.com/bugsnag/bugsnag-ruby/tree/master/docs/Notification Options.md)
 - [Demo Applications](#demo-applications)
 - [Support](#support)
 - [Contributing](#contributing)
 - [License](#license)
 
-- [Additional Documentation](https://github.com/bugsnag/bugsnag-ruby/tree/master/docs)
-	- [Configuration](docs/Configuration.md)
-	- [Notification Options](docs/Notification Options.md)
-
-
 
 Getting Started
 ---------------
@@ -69,17 +66,19 @@ Getting Started
     end
     ```
 
-    The Bugsnag module will read the `BUGSNAG_API_KEY` environment variable if you
-    do not configure one automatically.
+    The Bugsnag module will read the `BUGSNAG_API_KEY` environment variable if
+    you do not configure one automatically.
 
 ### Rake Integration
 
-Rake integration is automatically enabled in Rails 3/4 apps, so providing you load the environment
-in your Rake tasks you dont need to do anything to get Rake support. If you choose not to load
-your environment, you can manually configure Bugsnag with a `bugsnag.configure` block in the Rakefile.
+Rake integration is automatically enabled in Rails 3/4/5 apps, so providing you
+load the environment in your Rake tasks you dont need to do anything to get Rake
+support. If you choose not to load your environment, you can manually configure
+Bugsnag with a `bugsnag.configure` block in the Rakefile.
 
-Bugsnag can automatically notify of all exceptions that happen in your rake tasks. In order
-to enable this, you need to `require "bugsnag/rake"` in your Rakefile, like so:
+Bugsnag can automatically notify of all exceptions that happen in your rake
+tasks. In order to enable this, you need to `require "bugsnag/rake"` in your
+Rakefile, like so:
 
 ```ruby
 require File.expand_path('../config/application', __FILE__)
@@ -93,27 +92,29 @@ end
 YourApp::Application.load_tasks
 ```
 
-> Note: We also configure Bugsnag in the Rakefile, so the tasks that do not load the full
-environment can still notify Bugsnag.
+> Note: We also configure Bugsnag in the Rakefile, so the tasks that do not load
+> the full environment can still notify Bugsnag.
 
 ### Sending a Test Notification
 
-To test that bugsnag is properly configured, you can use the `test_exception` rake task:
+To test that bugsnag is properly configured, you can use the `test_exception`
+rake task:
 
 ```bash
 rake bugsnag:test_exception
 ```
 
-A test exception will be sent to your bugsnag dashboard if everything is configured correctly.
+A test exception will be sent to your bugsnag dashboard if everything is
+configured correctly.
 
 Usage
 -----
 
 ### Catching and Reporting Exceptions
 
-Bugsnag Ruby works out of the box with Rails, Sidekiq, Resque, DelayedJob (3+), Mailman, Rake and Rack. It
-should be easy to add support for other frameworks, either by sending a pull request here or adding a hook
-to those projects.
+Bugsnag Ruby works out of the box with Rails, Sidekiq, Resque, DelayedJob (3+),
+Mailman, Rake and Rack. It should be easy to add support for other frameworks,
+either by sending a pull request here or adding a hook to those projects.
 
 #### Rack/Sinatra Apps
 

data/VERSION

@@ -1 +1 @@
-2.8.13
+3.0.0

data/bugsnag.gemspec

@@ -28,5 +28,6 @@ Gem::Specification.new do |s|
   s.add_development_dependency 'rspec'
   s.add_development_dependency 'rdoc'
   s.add_development_dependency 'pry'
+  s.add_development_dependency 'addressable', '~> 2.3.8'
   s.add_development_dependency 'webmock'
 end

data/lib/bugsnag.rb

@@ -5,6 +5,7 @@ require "bugsnag/version"
 require "bugsnag/configuration"
 require "bugsnag/meta_data"
 require "bugsnag/notification"
+require "bugsnag/cleaner"
 require "bugsnag/helpers"
 require "bugsnag/deploy"
 

data/lib/bugsnag/cleaner.rb

@@ -0,0 +1,122 @@
+require 'uri'
+
+module Bugsnag
+  class Cleaner
+    ENCODING_OPTIONS = {:invalid => :replace, :undef => :replace}.freeze
+    FILTERED = '[FILTERED]'.freeze
+    RECURSION = '[RECURSION]'.freeze
+    OBJECT = '[OBJECT]'.freeze
+
+    def initialize(filters)
+      @filters = Array(filters)
+      @deep_filters = @filters.any? {|f| f.kind_of?(Regexp) && f.to_s.include?("\\.".freeze) }
+    end
+
+    def clean_object(obj)
+      traverse_object(obj, {}, nil)
+    end
+
+    def traverse_object(obj, seen, scope)
+      return nil unless obj
+
+      # Protect against recursion of recursable items
+      protection = if obj.is_a?(Hash) || obj.is_a?(Array) || obj.is_a?(Set)
+        return seen[obj] if seen[obj]
+        seen[obj] = RECURSION
+      end
+
+      value = case obj
+      when Hash
+        clean_hash = {}
+        obj.each do |k,v|
+          if filters_match_deeply?(k, scope)
+            clean_hash[k] = FILTERED
+          else
+            clean_hash[k] = traverse_object(v, seen, [scope, k].compact.join('.'))
+          end
+        end
+        clean_hash
+      when Array, Set
+        obj.map { |el| traverse_object(el, seen, scope) }.compact
+      when Numeric, TrueClass, FalseClass
+        obj
+      when String
+        clean_string(obj)
+      else
+        str = obj.to_s
+        # avoid leaking potentially sensitive data from objects' #inspect output
+        if str =~ /#<.*>/
+          OBJECT
+        else
+          clean_string(str)
+        end
+      end
+
+      seen[obj] = value if protection
+      value
+    end
+
+    def clean_string(str)
+      if defined?(str.encoding) && defined?(Encoding::UTF_8)
+        if str.encoding == Encoding::UTF_8
+          str.valid_encoding? ? str : str.encode('utf-16', ENCODING_OPTIONS).encode('utf-8')
+        else
+          str.encode('utf-8', ENCODING_OPTIONS)
+        end
+      elsif defined?(Iconv)
+        Iconv.conv('UTF-8//IGNORE', 'UTF-8', str) || str
+      else
+        str
+      end
+    end
+
+    def self.clean_object_encoding(obj)
+      new(nil).clean_object(obj)
+    end
+
+    def clean_url(url)
+      return url if @filters.empty?
+
+      uri = URI(url)
+      return url unless uri.query
+
+      query_params = uri.query.split('&').map { |pair| pair.split('=') }
+      query_params.map! do |key, val|
+        if filters_match?(key)
+          "#{key}=#{FILTERED}"
+        else
+          "#{key}=#{val}"
+        end
+      end
+
+      uri.query = query_params.join('&')
+      uri.to_s
+    end
+
+    private
+
+    def filters_match?(key)
+      str = key.to_s
+
+      @filters.any? do |f|
+        case f
+        when Regexp
+          str.match(f)
+        else
+          str.include?(f.to_s)
+        end
+      end
+    end
+
+    # If someone has a Rails filter like /^stuff\.secret/, it won't match "request.params.stuff.secret",
+    # so we try it both with and without the "request.params." bit.
+    def filters_match_deeply?(key, scope)
+      return true if filters_match?(key)
+      return false unless @deep_filters
+
+      long = [scope, key].compact.join('.')
+      short = long.sub(/^request\.params\./, '')
+      filters_match?(long) || filters_match?(short)
+    end
+  end
+end

data/lib/bugsnag/delivery/thread_queue.rb

@@ -24,8 +24,8 @@ module Bugsnag
 
         def start_once!
           MUTEX.synchronize do
-            return if @started
-            @started = true
+            return if @started == Process.pid
+            @started = Process.pid
 
             @queue = Queue.new
 

data/lib/bugsnag/helpers.rb

@@ -3,98 +3,6 @@ require 'uri'
 module Bugsnag
   module Helpers
     MAX_STRING_LENGTH = 4096
-    ENCODING_OPTIONS = {:invalid => :replace, :undef => :replace}.freeze
-
-    def self.cleanup_obj(obj, filters = nil, seen = {})
-      return nil unless obj
-
-      # Protect against recursion of recursable items
-      protection = if obj.is_a?(Hash) || obj.is_a?(Array) || obj.is_a?(Set)
-        return seen[obj] if seen[obj]
-        seen[obj] = '[RECURSION]'.freeze
-      end
-
-      value = case obj
-      when Hash
-        clean_hash = {}
-        obj.each do |k,v|
-          if filters_match?(k, filters)
-            clean_hash[k] = '[FILTERED]'.freeze
-          else
-            clean_obj = cleanup_obj(v, filters, seen)
-            clean_hash[k] = clean_obj
-          end
-        end
-        clean_hash
-      when Array, Set
-        obj.map { |el| cleanup_obj(el, filters, seen) }.compact
-      when Numeric, TrueClass, FalseClass
-        obj
-      when String
-        cleanup_string(obj)
-      else
-        str = obj.to_s
-        # avoid leaking potentially sensitive data from objects' #inspect output
-        if str =~ /#<.*>/
-          '[OBJECT]'.freeze
-        else
-          cleanup_string(str)
-        end
-      end
-
-      seen[obj] = value if protection
-      value
-    end
-
-    def self.cleanup_string(str)
-      if defined?(str.encoding) && defined?(Encoding::UTF_8)
-        if str.encoding == Encoding::UTF_8
-          str.valid_encoding? ? str : str.encode('utf-16', ENCODING_OPTIONS).encode('utf-8')
-        else
-          str.encode('utf-8', ENCODING_OPTIONS)
-        end
-      elsif defined?(Iconv)
-        Iconv.conv('UTF-8//IGNORE', 'UTF-8', str) || str
-      else
-        str
-      end
-    end
-
-    def self.cleanup_obj_encoding(obj)
-      cleanup_obj(obj, nil)
-    end
-
-    def self.filters_match?(object, filters)
-      str = object.to_s
-
-      Array(filters).any? do |f|
-        case f
-        when Regexp
-          str.match(f)
-        else
-          str.include?(f.to_s)
-        end
-      end
-    end
-
-    def self.cleanup_url(url, filters = [])
-      return url if filters.empty?
-
-      uri = URI(url)
-      return url unless uri.query
-
-      query_params = uri.query.split('&').map { |pair| pair.split('=') }
-      query_params.map! do |key, val|
-        if filters_match?(key, filters)
-          "#{key}=[FILTERED]"
-        else
-          "#{key}=#{val}"
-        end
-      end
-
-      uri.query = query_params.join('&')
-      uri.to_s
-    end
 
     def self.reduce_hash_size(hash)
       return {} unless hash.is_a?(Hash)

data/lib/bugsnag/middleware/rack_request.rb

@@ -23,7 +23,7 @@ module Bugsnag::Middleware
         # Build the clean url (hide the port if it is obvious)
         url = "#{request.scheme}://#{request.host}"
         url << ":#{request.port}" unless [80, 443].include?(request.port)
-        url << Bugsnag::Helpers.cleanup_url(request.fullpath, notification.configuration.params_filters)
+        url << Bugsnag::Cleaner.new(notification.configuration.params_filters).clean_url(request.fullpath)
 
         headers = {}
 

data/lib/bugsnag/middleware/rails2_request.rb

@@ -19,7 +19,7 @@ module Bugsnag::Middleware
         # Build the clean url
         url = "#{request.protocol}#{request.host}"
         url << ":#{request.port}" unless [80, 443].include?(request.port)
-        url << Bugsnag::Helpers.cleanup_url(request.fullpath, notification.configuration.params_filters)
+        url << Bugsnag::Cleaner.new(notification.configuration.params_filters).clean_url(request.fullpath)
 
         # Add a request tab
         notification.add_tab(:request, {

data/lib/bugsnag/notification.rb

@@ -250,10 +250,10 @@ module Bugsnag
       payload_event[:device] = {:hostname => @configuration.hostname} if @configuration.hostname
 
       # cleanup character encodings
-      payload_event = Bugsnag::Helpers.cleanup_obj_encoding(payload_event)
+      payload_event = Bugsnag::Cleaner.clean_object_encoding(payload_event)
 
       # filter out sensitive values in (and cleanup encodings) metaData
-      payload_event[:metaData] = Bugsnag::Helpers.cleanup_obj(@meta_data, @configuration.params_filters)
+      payload_event[:metaData] = Bugsnag::Cleaner.new(@configuration.params_filters).clean_object(@meta_data)
       payload_event.reject! {|k,v| v.nil? }
 
       # return the payload hash

data/lib/bugsnag/rails/controller_methods.rb

@@ -17,7 +17,7 @@ module Bugsnag::Rails
       def _add_bugsnag_notify_callback(callback_key, *methods, &block)
         options = methods.last.is_a?(Hash) ? methods.pop : {}
 
-        before_filter(options) do |controller|
+        action = lambda do |controller|
           request_data = Bugsnag.configuration.request_data
           request_data[callback_key] ||= []
 
@@ -33,6 +33,11 @@ module Bugsnag::Rails
             controller.instance_exec(notification, &block)
           } if block_given?
         end
+        if respond_to?(:before_action)
+          before_action(options, &action)
+        else
+          before_filter(options, &action)
+        end
       end
     end
 

data/spec/cleaner_spec.rb

@@ -0,0 +1,138 @@
+# 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/helper_spec.rb

@@ -3,68 +3,6 @@
 require 'spec_helper'
 
 describe Bugsnag::Helpers do
-  it "cleans up recursive hashes" do
-    a = {:a => {}}
-    a[:a][:b] = a
-    expect(Bugsnag::Helpers.cleanup_obj(a)).to eq({:a => {:b => "[RECURSION]"}})
-  end
-
-  it "cleans up recursive arrays" do
-    a = []
-    a << a
-    a << "hello"
-    expect(Bugsnag::Helpers.cleanup_obj(a)).to eq(["[RECURSION]", "hello"])
-  end
-
-  it "allows multiple copies of the same string" do
-    a = {:name => "bugsnag"}
-    a[:second] = a[:name]
-    expect(Bugsnag::Helpers.cleanup_obj(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(Bugsnag::Helpers.cleanup_obj(a)).to eq([["hello"], ["hello"]])
-  end
-
-  it "cleans up UTF8 strings properly" do
-    obj = "André"
-    expect(Bugsnag::Helpers.cleanup_obj(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(Bugsnag::Helpers.cleanup_obj(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(Bugsnag::Helpers.cleanup_obj(obj)).to eq("Andr��")
-    end
-  end
-
-  it "filters by string inclusion" do
-    expect(Bugsnag::Helpers.cleanup_obj({ :foo => 'bar' }, ['f'])).to eq({ :foo => '[FILTERED]' })
-    expect(Bugsnag::Helpers.cleanup_obj({ :foo => 'bar' }, ['b'])).to eq({ :foo => 'bar' })
-  end
-
-  it "filters by regular expression" do
-    expect(Bugsnag::Helpers.cleanup_obj({ :foo => 'bar' }, [/fb?/])).to eq({ :foo => '[FILTERED]' })
-    expect(Bugsnag::Helpers.cleanup_obj({ :foo => 'bar' }, [/fb+/])).to eq({ :foo => 'bar' })
-  end
-
   it "reduces hash size correctly" do
     meta_data = {
       :key_one => "this should not be truncated",
@@ -89,56 +27,4 @@ describe Bugsnag::Helpers do
     expect(meta_data[:key_one].length).to eq(28)
     expect(meta_data[:key_one]).to eq("this should not be truncated")
   end
-
-  it "works with no filters configured" do
-    url = Bugsnag::Helpers.cleanup_url "/dir/page?param1=value1&param2=value2"
-
-    expect(url).to eq("/dir/page?param1=value1&param2=value2")
-  end
-
-  it "does not filter with no get params" do
-    url = Bugsnag::Helpers.cleanup_url "/dir/page"
-
-    expect(url).to eq("/dir/page")
-  end
-
-  it "leaves a url alone if no filters match" do
-    url = Bugsnag::Helpers.cleanup_url "/dir/page?param1=value1&param2=value2", ["param3"]
-
-    expect(url).to eq("/dir/page?param1=value1&param2=value2")
-  end
-
-  it "filters a single get param" do
-    url = Bugsnag::Helpers.cleanup_url "/dir/page?param1=value1&param2=value2", ["param1"]
-
-    expect(url).to eq("/dir/page?param1=[FILTERED]&param2=value2")
-  end
-
-  it "filters a get param that contains a filtered term" do
-    url = Bugsnag::Helpers.cleanup_url '/dir/page?param1=value1&param2=value2&bla=yes', ["param"]
-
-    expect(url).to eq("/dir/page?param1=[FILTERED]&param2=[FILTERED]&bla=yes")
-  end
-
-  it "filters multiple matches" do
-    url = Bugsnag::Helpers.cleanup_url "/dir/page?param1=value1&param2=value2&param3=value3", ["param1", "param2"]
-
-    expect(url).to eq("/dir/page?param1=[FILTERED]&param2=[FILTERED]&param3=value3")
-  end
-
-  it "filters using a combination of string and regex filters" do
-    url = Bugsnag::Helpers.cleanup_url "/dir/page?param1=value1&param2=value2&param3=value3", ["param1", /param2/]
-
-    expect(url).to eq("/dir/page?param1=[FILTERED]&param2=[FILTERED]&param3=value3")
-  end
-
-  it "filters regex matches" do
-    url = Bugsnag::Helpers.cleanup_url "https://host.example/sessions?access_token=abc123", [/\Aaccess_token\z/]
-    expect(url).to eq("https://host.example/sessions?access_token=[FILTERED]")
-  end
-
-  it "filters partial regex matches" do
-    url = Bugsnag::Helpers.cleanup_url "https://host.example/sessions?access_token=abc123", [/token/]
-    expect(url).to eq("https://host.example/sessions?access_token=[FILTERED]")
-  end
 end

data/spec/integration_spec.rb

@@ -17,6 +17,7 @@ describe 'Bugsnag' do
   end
   after do
     server.stop
+    queue.clear
   end
 
   let(:request) { JSON.parse(queue.pop) }
@@ -68,6 +69,27 @@ describe 'Bugsnag' do
     expect(request['events'][0]['exceptions'][0]['message']).to eq('yo')
   end
 
+  it 'should work with threadpool delivery after fork' do
+    is_jruby = defined?(RUBY_ENGINE) && RUBY_ENGINE == 'jruby'
+    unless is_jruby #jruby doesn't support fork, so this test doesn't apply
+      Bugsnag.configure do |config|
+        config.endpoint = "localhost:#{server.config[:Port]}"
+        config.use_ssl = false
+        config.delivery_method = :thread_queue
+      end
+      WebMock.allow_net_connect!
+
+      Bugsnag.notify 'yo'
+
+      Process.fork do
+        Bugsnag.notify 'yo too'
+      end
+      Process.wait
+
+      expect(queue.length).to eq(2)
+    end
+  end
+
   describe 'with a proxy' do
     proxy = nil
     pqueue = Queue.new

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: bugsnag
 version: !ruby/object:Gem::Version
-  version: 2.8.13
+  version: 3.0.0
 platform: ruby
 authors:
 - James Smith
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-12-04 00:00:00.000000000 Z
+date: 2015-12-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: json
@@ -86,6 +86,20 @@ dependencies:
     - - '>='
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: addressable
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.3.8
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.3.8
 - !ruby/object:Gem::Dependency
   name: webmock
   requirement: !ruby/object:Gem::Requirement
@@ -126,6 +140,7 @@ files:
 - lib/bugsnag.rb
 - lib/bugsnag/capistrano.rb
 - lib/bugsnag/capistrano2.rb
+- lib/bugsnag/cleaner.rb
 - lib/bugsnag/configuration.rb
 - lib/bugsnag/delay/resque.rb
 - lib/bugsnag/delayed_job.rb
@@ -161,6 +176,7 @@ files:
 - lib/bugsnag/version.rb
 - lib/generators/bugsnag/bugsnag_generator.rb
 - rails/init.rb
+- spec/cleaner_spec.rb
 - spec/code_spec.rb
 - spec/fixtures/crashes/end_of_file.rb
 - spec/fixtures/crashes/short_file.rb