raygun4ruby 1.1.12 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3d4305c691bbd89f3d54ba89ba86700fe30cc9b6
-  data.tar.gz: cc9292411c93c1f5515daa8beafe5258a2ac6127
+  metadata.gz: 880e6dc1a2610cd344816502b0ff0b9c8025a48c
+  data.tar.gz: 4c5be5b014cbbf39a9433a43a2cb36af56262832
 SHA512:
-  metadata.gz: c0db0e82e960a9e65ebbcf22aa95ef25582772db257e0a11058902703178d2636b2d5f7c3bb84e2cd1b41ba88a62b28139f74d5de5d147ab26b949470e89dc8d
-  data.tar.gz: 9b352669522765bad9a218bcdc41cd291fcd8ffe2220978d0f1373a2b4de025cd88e07d62019da44fc9b8b6eaba6bd37ac26b3730c30ba1e512de0692d3651f0
+  metadata.gz: a5d1eaba8ca8a31a4e1b66b6444af7d478ac4e64bd3fff3629777ca513de4265ce3f64348c2dc97e27ef6051e960000be0cc295de803e43b067b998d4a320dd6
+  data.tar.gz: 11a0d8f62960c06dfb43530a23df400f8d976e32ad97325a756acf7eaf6ecda321fd19b2c87b5665f21241e4db1a78a0b61ce18d39ccb854e0b95617b95060c7

data/CHANGELOG.md

@@ -0,0 +1,9 @@
+## 1.2.0 (09/03/2017)
+
+Features:
+  - Added two new configuration options, `filter_payload_with_whitelist` and `whitelist_payload_shape`
+    - See [README.md](https://github.com/MindscapeHQ/raygun4ruby#filtering-the-payload-by-whitelist) for an example of how to use them
+  - When raygun4ruby encounters an exception trying to track an exception it will try once to send that exception to Raygun so you are notified
+
+Bugfixes:
+  - raygun4ruby will no longer crash and suppress app exceptions when the API key is not configured

data/README.md

@@ -91,6 +91,53 @@ Raygun.setup do |config|
 end
 ```
 
+### Filtering the payload by whitelist
+
+As an alternative to the above, you can also opt-in to the keys/values to be sent to Raygun by providing a specific whitelist of the keys you want to transmit.
+
+This disables the blacklist filtering above (`filter_parameters`), and is applied to the entire payload (error, request, environment and custom data included), not just the request parameters.
+
+In order to opt-in to this feature, set `filter_payload_with_whitelist` to `true`, and specify a shape of what keys you want (the default is below which is to allow everything through, this also means that the query parameters filtered out by default like password, creditcard etc will not be unless changed):
+
+```ruby
+Raygun.setup do |config|
+  config.api_key = "YOUR_RAYGUN_API_KEY"
+  config.filter_payload_with_whitelist = true
+
+  config.whitelist_payload_shape = {
+      machineName: true,
+      version: true,
+      error: true,
+      userCustomData: true,
+      tags: true,
+      request: {
+        hostName: true,
+        url: true,
+        httpMethod: true,
+        iPAddress: true,
+        queryString: true,
+        headers: true,
+        form: {}, # Set to empty hash so that it doesn't just filter out the whole thing, but instead filters out each individual param
+        rawData: true
+      }
+    }
+end
+```
+
+Alternatively, provide a Proc to filter the payload using your own logic:
+
+```ruby
+Raygun.setup do |config|
+  config.api_key = "YOUR_RAYGUN_API_KEY"
+  config.filter_payload_with_whitelist = true
+
+  config.whitelist_payload_keys do |payload|
+    # Return the payload mutated into your desired form
+    payload
+  end
+end
+```
+
 ### Custom User Data
 Custom data can be added to `track_exception` by passing a custom_data key in the second parameter hash.
 
@@ -226,6 +273,10 @@ Raygun4Ruby can track errors from Sidekiq (2.x or 3+). All you need to do is add
 
 Either in your Raygun initializer or wherever else takes your fancy :)
 
+### Other Configuration options
+
+For a complete list of configuration options see the [configuration.rb](https://github.com/MindscapeHQ/raygun4ruby/blob/master/lib/raygun/configuration.rb) file
+
 ## Found a bug?
 
 Oops! Just let us know by opening an Issue on Github.

data/lib/raygun/client.rb

@@ -116,7 +116,7 @@ module Raygun
 
       def form_params(env)
         params = action_dispatch_params(env) || rack_params(env) || {}
-        filter_params(params, env["action_dispatch.parameter_filter"])
+        filter_params_with_blacklist(params, env["action_dispatch.parameter_filter"])
       end
 
       def action_dispatch_params(env)
@@ -137,7 +137,7 @@ module Raygun
 
       def filter_custom_data(env)
         params = env.delete(:custom_data) || {}
-        filter_params(params, env["action_dispatch.parameter_filter"])
+        filter_params_with_blacklist(params, env["action_dispatch.parameter_filter"])
       end
 
       # see http://raygun.io/raygun-providers/rest-json-api?v=1
@@ -145,7 +145,11 @@ module Raygun
         custom_data = filter_custom_data(env) || {}
         tags = env.delete(:tags) || []
 
-        tags << rails_env || rack_env
+        if rails_env
+          tags << rails_env
+        else
+          tags << rack_env
+        end
 
         grouping_key = env.delete(:grouping_key)
 
@@ -163,6 +167,10 @@ module Raygun
 
         error_details.merge!(user: user_information(env)) if affected_user_present?(env)
 
+        if Raygun.configuration.filter_payload_with_whitelist
+          error_details = filter_payload_with_whitelist(error_details)
+        end
+
         {
           occurredOn: Time.now.utc.iso8601,
           details:    error_details
@@ -173,17 +181,29 @@ module Raygun
         self.class.post("/entries", verify_peer: true, verify: true, headers: @headers, body: JSON.generate(payload_hash))
       end
 
-      def filter_params(params_hash, extra_filter_keys = nil)
-        if Raygun.configuration.filter_parameters.is_a?(Proc)
-          filter_params_with_proc(params_hash, Raygun.configuration.filter_parameters)
+      def filter_params_with_blacklist(params_hash = {}, extra_filter_keys = nil)
+        return params_hash if Raygun.configuration.filter_payload_with_whitelist
+
+        filter_parameters = Raygun.configuration.filter_parameters
+
+        if filter_parameters.is_a? Proc
+          filter_parameters.call(params_hash)
         else
-          filter_keys = (Array(extra_filter_keys) + Raygun.configuration.filter_parameters).map(&:to_s)
+          filter_keys = (Array(extra_filter_keys) + filter_parameters).map(&:to_s)
+
           filter_params_with_array(params_hash, filter_keys)
         end
       end
 
-      def filter_params_with_proc(params_hash, proc)
-        proc.call(params_hash)
+      def filter_payload_with_whitelist(payload_hash)
+        shape = Raygun.configuration.whitelist_payload_shape
+
+        if shape.is_a? Proc
+          shape.call(payload_hash)
+        else
+          # Always keep the client hash, so force it to true here
+          Services::ApplyWhitelistFilterToPayload.new.call(shape.merge(client: true), payload_hash)
+        end
       end
 
       def filter_params_with_array(params_hash, filter_keys)

data/lib/raygun/configuration.rb

@@ -26,7 +26,7 @@ module Raygun
     # Tags to send with each exception
     config_option :tags
 
-    # Logger to use when if we find an exception :)
+    # Logger to use when we find an exception :)
     config_option :logger
 
     # Should we actually report exceptions to Raygun? (Usually disabled in Development mode, for instance)
@@ -44,6 +44,12 @@ module Raygun
     # Which parameter keys should we filter out by default?
     config_option :filter_parameters
 
+    # Should we switch to a white listing mode for keys instead of the default blacklist?
+    config_option :filter_payload_with_whitelist
+
+    # If :filter_payload_with_whitelist is true, which keys should we whitelist?
+    config_option :whitelist_payload_shape
+
     # Hash of proxy settings - :address, :port (defaults to 80), :username and :password (both default to nil)
     config_option :proxy_settings
 
@@ -59,6 +65,25 @@ module Raygun
 
     DEFAULT_FILTER_PARAMETERS = [ :password, :card_number, :cvv ]
 
+    DEFAULT_WHITELIST_PAYLOAD_SHAPE_REQUEST = {
+      hostName: true,
+      url: true,
+      httpMethod: true,
+      iPAddress: true,
+      queryString: true,
+      headers: true,
+      form: {}, # Set to empty hash so that it doesn't just filter out the whole thing, but instead filters out each individual param
+      rawData: true
+    }.freeze
+    DEFAULT_WHITELIST_PAYLOAD_SHAPE = {
+      machineName: true,
+      version: true,
+      error: true,
+      userCustomData: true,
+      tags: true,
+      request: DEFAULT_WHITELIST_PAYLOAD_SHAPE_REQUEST
+    }.freeze
+
     attr_reader :defaults
 
     def initialize
@@ -73,6 +98,8 @@ module Raygun
         affected_user_method:             :current_user,
         affected_user_identifier_methods: [ :email, :username, :id ],
         filter_parameters:                DEFAULT_FILTER_PARAMETERS,
+        filter_payload_with_whitelist:    false,
+        whitelist_payload_shape:          DEFAULT_WHITELIST_PAYLOAD_SHAPE,
         proxy_settings:                   {}
       })
     end
@@ -98,6 +125,11 @@ module Raygun
       read_value(:filter_parameters)
     end
 
+    def whitelist_payload_shape(&filter_proc)
+      set_value(:whitelist_payload_shape, filter_proc) if block_given?
+      read_value(:whitelist_payload_shape)
+    end
+
     private
 
       def read_value(name)

data/lib/raygun/middleware/rack_exception_interceptor.rb

@@ -9,10 +9,10 @@ module Raygun
       def call(env)
         response = @app.call(env)
       rescue Exception => exception
-        Raygun.track_exception(exception, env)
+        Raygun.track_exception(exception, env) if Raygun.configured?
         raise exception
       end
 
     end
   end
-end
+end

data/lib/raygun/middleware/rails_insert_affected_user.rb

@@ -22,11 +22,10 @@ module Raygun
 
             env["raygun.affected_user"] = { :identifier => identifier }
           end
-          
         end
         raise exception
       end
 
     end
   end
-end
+end

data/lib/raygun/railtie.rb

@@ -1,5 +1,4 @@
 class Raygun::Railtie < Rails::Railtie
-
   initializer "raygun.configure_rails_initialization" do |app|
 
     # Thanks Airbrake: See https://github.com/rails/rails/pull/8624
@@ -34,5 +33,4 @@ class Raygun::Railtie < Rails::Railtie
   rake_tasks do
     load "tasks/raygun.tasks"
   end
-
 end

data/lib/raygun/services/apply_whitelist_filter_to_payload.rb

@@ -0,0 +1,23 @@
+module Raygun
+  module Services
+    class ApplyWhitelistFilterToPayload
+      def call(whitelist, payload)
+        filter_hash(whitelist, payload)
+      end
+
+      private
+
+      def filter_hash(whitelist, hash)
+        hash.each do |k, v|
+          unless whitelist && (whitelist[k] || whitelist[k.to_sym])
+            hash[k] = '[FILTERED]'
+          end
+
+          if v.is_a?(Hash) && whitelist[k].is_a?(Hash)
+            filter_hash(whitelist[k], v)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/raygun/version.rb

@@ -1,3 +1,3 @@
 module Raygun
-  VERSION = "1.1.12"
+  VERSION = "1.2.0"
 end

data/lib/raygun.rb

@@ -10,7 +10,12 @@ require "raygun/configuration"
 require "raygun/client"
 require "raygun/middleware/rack_exception_interceptor"
 require "raygun/testable"
+require "raygun/services/apply_whitelist_filter_to_payload"
 require "raygun/railtie" if defined?(Rails)
+begin
+  require "pry"
+rescue LoadError
+end
 
 module Raygun
 
@@ -37,7 +42,11 @@ module Raygun
       configuration.defaults
     end
 
-    def track_exception(exception_instance, env = {})
+    def configured?
+      !!configuration.api_key
+    end
+
+    def track_exception(exception_instance, env = {}, retry_count = 1)
       if should_report?(exception_instance)
         log("[Raygun] Tracking Exception...")
         Client.new.track_exception(exception_instance, env)
@@ -45,6 +54,16 @@ module Raygun
     rescue Exception => e
       if configuration.failsafe_logger
         failsafe_log("Problem reporting exception to Raygun: #{e.class}: #{e.message}\n\n#{e.backtrace.join("\n")}")
+      end
+
+      if retry_count > 0
+        new_exception = e.exception("raygun4ruby encountered an exception processing your exception")
+        new_exception.set_backtrace(e.backtrace)
+
+        env[:custom_data] ||= {}
+        env[:custom_data].merge!(original_stacktrace: exception_instance.backtrace)
+
+        track_exception(new_exception, env, retry_count - 1)
       else
         raise e
       end
@@ -66,6 +85,10 @@ module Raygun
 
     private
 
+      def print_api_key_warning
+        $stderr.puts(NO_API_KEY_MESSAGE)
+      end
+
       def should_report?(exception)
         return false if configuration.silence_reporting
         return false if configuration.ignore.flatten.include?(exception.class.to_s)

data/raygun4ruby.gemspec

@@ -32,4 +32,5 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "resque"
   spec.add_development_dependency "sidekiq", [">= 3", "< 3.2.2"]
   spec.add_development_dependency "mocha"
+  spec.add_development_dependency "pry"
 end

data/specs/services/apply_whitelist_filter_to_payload_spec.rb

@@ -0,0 +1,253 @@
+require "minitest/autorun"
+require "minitest/pride"
+require_relative "../../lib/raygun"
+
+module Raygun
+  module Services
+    describe ApplyWhitelistFilterToPayload do
+      let(:service) { ApplyWhitelistFilterToPayload.new }
+
+      describe "top level keys" do
+        let(:payload) do
+          { foo: 1, bar: 2 }
+        end
+        let(:expected) do
+          { foo: 1 , bar: '[FILTERED]'}
+        end
+
+        it "filters out keys that are not present in the shape" do
+          shape = {
+            foo: true
+          }
+
+          new_payload = service.call(shape, payload)
+
+          new_payload.must_equal(expected)
+        end
+
+        it "filters out keys that are set to false" do
+          shape = {
+            foo: true,
+            bar: false
+          }
+
+          new_payload = service.call(shape, payload)
+
+          new_payload.must_equal(expected)
+        end
+      end
+
+      describe "nested hashes" do
+        let(:payload) {{
+          foo: 1,
+          bar: {
+            baz: 2,
+            qux: 3
+          }
+        }}
+        let(:expected) {{
+          foo: 1,
+          bar: {
+            baz: 2,
+            qux: '[FILTERED]'
+          }
+        }}
+
+        it "filters out keys in nested hashes" do
+          shape = {
+            foo: true,
+            bar: {
+              baz: true
+            }
+          }
+
+          new_payload = service.call(shape, payload)
+
+          new_payload.must_equal(expected)
+        end
+
+        it "filters out a nested hash if the whitelist does not contain it" do
+          shape = {
+            foo: true
+          }
+          expected[:bar] = "[FILTERED]"
+
+          new_payload = service.call(shape, payload)
+
+          new_payload.must_equal(expected)
+        end
+
+        it "handles nested hashes when the whitelist is set to allow the whole hash" do
+          shape = {
+            bar: true
+          }
+          expected = {
+            foo: '[FILTERED]',
+            bar: {
+              baz: 2,
+              qux: 3
+            }
+          }
+
+          new_payload = service.call(shape, payload)
+
+          new_payload.must_equal(expected)
+        end
+
+        it "handles nested hashes when the whitelist is set to not allow the whole hash" do
+          shape = {
+            foo: true,
+            bar: false
+          }
+          expected = {
+            foo: 1,
+            bar: '[FILTERED]'
+          }
+
+          new_payload = service.call(shape, payload)
+
+          new_payload.must_equal(expected)
+        end
+      end
+
+      describe "string keys" do
+        it "handles the case where a payload key is a string and a whitelist key is a symbol" do
+          shape = {
+            foo: true
+          }
+          payload = {
+            "foo" => 1,
+            "bar" => 2
+          }
+          expected = {
+            "foo" => 1,
+            "bar" => '[FILTERED]'
+          }
+
+          new_payload = service.call(shape, payload)
+
+          new_payload.must_equal(expected)
+        end
+      end
+
+      it "handles a very complex shape" do
+        shape = {
+          machineName: true,
+          version: true,
+          client: true,
+          error: {
+            className: true,
+            message: true,
+            stackTrace: true
+          },
+          userCustomData: true,
+          tags: true,
+          request: {
+            hostName: true,
+            url: true,
+            httpMethod: true,
+            iPAddress: true,
+            queryString: {
+              param1: true,
+              param2: true,
+            },
+            headers: {
+              "Host" => true,
+              "Connection" => true,
+              "Upgrade-Insecure_requests" => true,
+              "User-Agent" => false,
+              "Accept" => true,
+            },
+            form: {
+              controller: true,
+              action: false
+            },
+            rawData: {
+              controller: true,
+              action: false
+            }
+          },
+          user: false,
+        }
+        payload = {
+          machineName: "mindscapes-MacBook-Pro.local",
+          version: nil,
+          client: {name: "Raygun4Ruby Gem", version: "1.1.12", clientUrl: "https://github.com/MindscapeHQ/raygun4ruby"},
+          error: {className: "Exception", message: "foo", stackTrace: []},
+          userCustomData: {},
+          tags: ["development"],
+          request: {
+            hostName: "localhost",
+            url: "/make-me-an-error-charlie",
+            httpMethod: "GET",
+            iPAddress: "::1",
+            queryString: {
+              param1: "1",
+              param2: "2",
+              param3: "3",
+            },
+            headers: {
+              "Host"=>"localhost:3000",
+              "Connection"=>"keep-alive",
+              "Upgrade-Insecure_requests"=>"1",
+              "User-Agent"=> "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_12_3) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/56.0.2924.87 Safari/537.36",
+              "Accept"=>"text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8",
+              "Accept-Encoding"=>"gzip, deflate, sdch, br",
+              "Accept-Language"=>"en-US,en;q=0.8",
+              "Version"=>"HTTP/1.1"
+            },
+            form: {
+              controller: "home",
+              action: "raise_error"
+            },
+            rawData: {
+              controller: "home",
+              action: "raise_error"
+            }
+          }
+        }
+        expected = {
+          machineName: "mindscapes-MacBook-Pro.local",
+          version: nil,
+          client: {name: "Raygun4Ruby Gem", version: "1.1.12", clientUrl: "https://github.com/MindscapeHQ/raygun4ruby"},
+          error: {className: "Exception", message: "foo", stackTrace: []},
+          userCustomData: {},
+          tags: ["development"],
+          request: {
+            hostName: "localhost",
+            url: "/make-me-an-error-charlie",
+            httpMethod: "GET",
+            iPAddress: "::1",
+            queryString: {
+              param1: "1",
+              param2: "2",
+              param3: '[FILTERED]'
+            },
+            headers: {
+              "Host"=>"localhost:3000",
+              "Connection"=>"keep-alive",
+              "Upgrade-Insecure_requests"=>"1",
+              "User-Agent" => "[FILTERED]",
+              "Accept"=>"text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8",
+              "Accept-Encoding" => "[FILTERED]",
+              "Accept-Language" => "[FILTERED]",
+              "Version" => "[FILTERED]"
+            },
+            form: {
+              controller: "home",
+              action: "[FILTERED]"
+            },
+            rawData: {
+              controller: "home",
+              action: "[FILTERED]"
+            }
+          }
+        }
+
+        new_payload = service.call(shape, payload)
+
+        new_payload.must_equal(expected)
+      end
+    end
+  end
+end

data/test/unit/client_test.rb

@@ -113,7 +113,7 @@ class ClientTest < Raygun::UnitTest
   end
 
   def test_unicode
-    e = TestException.new('日本語のメッセージ')
+    e = TestException.new('日本語のメッセージ です')
 
     assert_silent { @client.track_exception(e) }
   end
@@ -271,10 +271,12 @@ class ClientTest < Raygun::UnitTest
   def test_filter_parameters_using_proc
     # filter any parameters that start with "nsa_only"
     Raygun.configuration.filter_parameters do |hash|
-      hash.inject({}) do |sanitized_hash, pair|
-        k, v = pair
-        v = "[OUREYESONLY]" if k[0...8] == "nsa_only"
-        sanitized_hash[k] = v
+      hash.inject({}) do |sanitized_hash, (k, v)|
+        sanitized_hash[k] = if k.start_with? "nsa_only"
+                              "[OUREYESONLY]"
+                            else
+                              v
+                            end
         sanitized_hash
       end
     end
@@ -420,31 +422,391 @@ class ClientTest < Raygun::UnitTest
     end
   end
 
-  private
+  def test_filter_payload_with_whitelist_never_filters_toplevel
+    Timecop.freeze do
+      Raygun.configuration.filter_payload_with_whitelist = true
+      Raygun.configuration.whitelist_payload_shape = {}
+
+      e = TestException.new("A test message")
+      e.set_backtrace(["/some/folder/some_file.rb:123:in `some_method_name'",
+                       "/another/path/foo.rb:1234:in `block (3 levels) run'"])
+
+      client_details = @client.send(:client_details)
+
+      assert_equal Time.now.utc.iso8601, @client.send(:build_payload_hash, e)[:occurredOn]
+      assert_equal Hash, @client.send(:build_payload_hash, e)[:details].class
+    end
+  end
+
+  def test_filter_payload_with_whitelist_never_filters_client
+    Raygun.configuration.filter_payload_with_whitelist = true
+    Raygun.configuration.whitelist_payload_shape = {}
+
+    e = TestException.new("A test message")
+    e.set_backtrace(["/some/folder/some_file.rb:123:in `some_method_name'",
+                     "/another/path/foo.rb:1234:in `block (3 levels) run'"])
+
+    client_details = @client.send(:client_details)
+
+    assert_equal client_details, @client.send(:build_payload_hash, e)[:details][:client]
+  end
 
-    def sample_env_hash
-      {
-        "SERVER_NAME"=>"localhost",
-        "REQUEST_METHOD"=>"POST",
-        "REQUEST_PATH"=>"/",
-        "PATH_INFO"=>"/",
-        "QUERY_STRING"=>"",
-        "REQUEST_URI"=>"/",
-        "HTTP_VERSION"=>"HTTP/1.1",
-        "HTTP_HOST"=>"localhost:3000",
-        "HTTP_CONNECTION"=>"keep-alive",
-        "HTTP_CACHE_CONTROL"=>"max-age=0",
-        "HTTP_ACCEPT"=>"text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
-        "HTTP_USER_AGENT"=>"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_8_4) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/29.0.1547.22 Safari/537.36",
-        "HTTP_ACCEPT_ENCODING"=>"gzip,deflate,sdch",
-        "HTTP_ACCEPT_LANGUAGE"=>"en-US,en;q=0.8",
-        "HTTP_COOKIE"=>"cookieval",
-        "GATEWAY_INTERFACE"=>"CGI/1.2",
-        "SERVER_PORT"=>"3000",
-        "SERVER_PROTOCOL"=>"HTTP/1.1",
-        "SCRIPT_NAME"=>"",
-        "REMOTE_ADDR"=>"127.0.0.1"
+  def test_filter_payload_with_whitelist_default_error
+    Raygun.configuration.filter_payload_with_whitelist = true
+
+    e = TestException.new("A test message")
+    e.set_backtrace(["/some/folder/some_file.rb:123:in `some_method_name'",
+                     "/another/path/foo.rb:1234:in `block (3 levels) run'"])
+
+    details = @client.send(:build_payload_hash, e)[:details]
+
+    expected_hash = {
+      className: "ClientTest::TestException",
+      message:   e.message,
+      stackTrace: [
+        { lineNumber: "123",  fileName: "/some/folder/some_file.rb", methodName: "some_method_name" },
+        { lineNumber: "1234", fileName: "/another/path/foo.rb",      methodName: "block (3 levels) run" }
+      ]
+    }
+
+    assert_equal expected_hash, details[:error]
+  end
+
+  def test_filter_payload_with_whitelist_exclude_error_keys
+    Raygun.configuration.filter_payload_with_whitelist = true
+    Raygun.configuration.whitelist_payload_shape = {
+      error: {
+        className: true,
+        message: true,
+        stackTrace: true
       }
+    }
+
+    e = TestException.new("A test message")
+    e.set_backtrace(["/some/folder/some_file.rb:123:in `some_method_name'",
+                     "/another/path/foo.rb:1234:in `block (3 levels) run'"])
+
+    details = @client.send(:build_payload_hash, e)[:details]
+
+    expected_hash = {
+      className: "ClientTest::TestException",
+      message:   e.message,
+      stackTrace: [
+        { lineNumber: "123",  fileName: "/some/folder/some_file.rb", methodName: "some_method_name" },
+        { lineNumber: "1234", fileName: "/another/path/foo.rb",      methodName: "block (3 levels) run" }
+      ]
+    }
+
+    assert_equal expected_hash, details[:error]
+  end
+
+  def test_filter_payload_with_whitelist_exclude_error_except_stacktrace
+    Raygun.configuration.filter_payload_with_whitelist = true
+    Raygun.configuration.whitelist_payload_shape = {
+      error: {
+        className: true,
+        message: true,
+      }
+    }
+
+    e = TestException.new("A test message")
+    e.set_backtrace(["/some/folder/some_file.rb:123:in `some_method_name'",
+                     "/another/path/foo.rb:1234:in `block (3 levels) run'"])
+
+    details = @client.send(:build_payload_hash, e)[:details]
+
+    expected_hash = {
+      className: "ClientTest::TestException",
+      message: "A test message",
+      stackTrace: "[FILTERED]"
+    }
+
+    assert_equal expected_hash, details[:error]
+  end
+
+  def test_filter_payload_with_whitelist_proc
+    Raygun.configuration.filter_payload_with_whitelist = true
+    Raygun.configuration.whitelist_payload_shape do |payload|
+      payload
     end
 
+    e = TestException.new("A test message")
+    e.set_backtrace(["/some/folder/some_file.rb:123:in `some_method_name'",
+                     "/another/path/foo.rb:1234:in `block (3 levels) run'"])
+
+    details = @client.send(:build_payload_hash, e)[:details]
+
+    expected_hash = {
+      className: "ClientTest::TestException",
+      message: "A test message",
+      stackTrace: [
+        { lineNumber: "123",  fileName: "/some/folder/some_file.rb", methodName: "some_method_name" },
+        { lineNumber: "1234", fileName: "/another/path/foo.rb",      methodName: "block (3 levels) run" }
+      ]
+    }
+
+    assert_equal expected_hash, details[:error]
+  end
+
+  def test_filter_payload_with_whitelist_default_request_post
+    Raygun.configuration.filter_payload_with_whitelist = true
+
+    e = TestException.new("A test message")
+    e.set_backtrace(["/some/folder/some_file.rb:123:in `some_method_name'",
+                     "/another/path/foo.rb:1234:in `block (3 levels) run'"])
+
+    post_body_env_hash = sample_env_hash.merge(
+      "rack.input"=>StringIO.new("a=b&c=4945438&password=swordfish")
+    )
+
+    details = @client.send(:build_payload_hash, e, post_body_env_hash)[:details]
+
+    expected_hash = {
+      hostName:    "localhost",
+      url:         "/",
+      httpMethod:  "POST",
+      iPAddress:   "127.0.0.1",
+      queryString: { },
+      headers:     { "Version"=>"HTTP/1.1", "Host"=>"localhost:3000", "Connection"=>"keep-alive", "Cache-Control"=>"max-age=0", "Accept"=>"text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8", "User-Agent"=>"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_8_4) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/29.0.1547.22 Safari/537.36", "Accept-Encoding"=>"gzip,deflate,sdch", "Accept-Language"=>"en-US,en;q=0.8", "Cookie"=>"cookieval" },
+      form:        { "a" => "[FILTERED]", "c" => "[FILTERED]", "password" => "[FILTERED]" },
+      rawData:     nil
+    }
+
+    assert_equal expected_hash, details[:request]
+  end
+
+  def test_filter_payload_with_whitelist_request_post_except_formkey
+    Raygun.configuration.filter_payload_with_whitelist = true
+    shape = Raygun.configuration.whitelist_payload_shape.dup
+    shape[:request] = Raygun.configuration.whitelist_payload_shape[:request].merge(
+      form: {
+        username: true
+      }
+    )
+    Raygun.configuration.whitelist_payload_shape = shape
+
+    e = TestException.new("A test message")
+    e.set_backtrace(["/some/folder/some_file.rb:123:in `some_method_name'",
+                     "/another/path/foo.rb:1234:in `block (3 levels) run'"])
+
+    post_body_env_hash = sample_env_hash.merge(
+      "rack.input"=>StringIO.new("username=foo&password=swordfish")
+    )
+
+    details = @client.send(:build_payload_hash, e, post_body_env_hash)[:details]
+
+    expected_hash = {
+      hostName:    "localhost",
+      url:         "/",
+      httpMethod:  "POST",
+      iPAddress:   "127.0.0.1",
+      queryString: { },
+      headers:     { "Version"=>"HTTP/1.1", "Host"=>"localhost:3000", "Connection"=>"keep-alive", "Cache-Control"=>"max-age=0", "Accept"=>"text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8", "User-Agent"=>"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_8_4) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/29.0.1547.22 Safari/537.36", "Accept-Encoding"=>"gzip,deflate,sdch", "Accept-Language"=>"en-US,en;q=0.8", "Cookie"=>"cookieval" },
+      form:        { "username" => "foo", "password" => "[FILTERED]" },
+      rawData:     nil
+    }
+
+    assert_equal expected_hash, details[:request]
+  end
+
+  def test_filter_payload_with_whitelist_default_request_get
+    Raygun.configuration.filter_payload_with_whitelist = true
+
+    e = TestException.new("A test message")
+    e.set_backtrace(["/some/folder/some_file.rb:123:in `some_method_name'",
+                     "/another/path/foo.rb:1234:in `block (3 levels) run'"])
+
+    sample_env_hash = {
+      "SERVER_NAME"=>"localhost",
+      "REQUEST_METHOD"=>"GET",
+      "REQUEST_PATH"=>"/",
+      "PATH_INFO"=>"/",
+      "QUERY_STRING"=>"a=b&c=4945438",
+      "REQUEST_URI"=>"/?a=b&c=4945438",
+      "HTTP_VERSION"=>"HTTP/1.1",
+      "HTTP_HOST"=>"localhost:3000",
+      "HTTP_CONNECTION"=>"keep-alive",
+      "HTTP_CACHE_CONTROL"=>"max-age=0",
+      "HTTP_ACCEPT"=>"text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
+      "HTTP_USER_AGENT"=>"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_8_4) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/29.0.1547.22 Safari/537.36",
+      "HTTP_ACCEPT_ENCODING"=>"gzip,deflate,sdch",
+      "HTTP_ACCEPT_LANGUAGE"=>"en-US,en;q=0.8",
+      "HTTP_COOKIE"=>"cookieval",
+      "GATEWAY_INTERFACE"=>"CGI/1.2",
+      "SERVER_PORT"=>"3000",
+      "SERVER_PROTOCOL"=>"HTTP/1.1",
+      "SCRIPT_NAME"=>"",
+      "REMOTE_ADDR"=>"127.0.0.1"
+    }
+
+    expected_hash = {
+      hostName:    "localhost",
+      url:         "/",
+      httpMethod:  "GET",
+      iPAddress:   "127.0.0.1",
+      queryString: { "a" => "b", "c" => "4945438" },
+      headers:     { "Version"=>"HTTP/1.1", "Host"=>"localhost:3000", "Connection"=>"keep-alive", "Cache-Control"=>"max-age=0", "Accept"=>"text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8", "User-Agent"=>"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_8_4) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/29.0.1547.22 Safari/537.36", "Accept-Encoding"=>"gzip,deflate,sdch", "Accept-Language"=>"en-US,en;q=0.8", "Cookie"=>"cookieval" },
+      form:        {},
+      rawData:     {}
+    }
+
+    details = @client.send(:build_payload_hash, e, sample_env_hash)[:details]
+
+    assert_equal expected_hash, details[:request]
+  end
+
+  def test_filter_payload_with_whitelist_default_request_get_except_querystring
+    Raygun.configuration.filter_payload_with_whitelist = true
+    shape = Raygun.configuration.whitelist_payload_shape.dup
+    shape[:request] = Raygun::Configuration::DEFAULT_WHITELIST_PAYLOAD_SHAPE_REQUEST.dup.tap do |h|
+      h.delete(:queryString)
+    end
+    Raygun.configuration.whitelist_payload_shape = shape
+
+    e = TestException.new("A test message")
+    e.set_backtrace(["/some/folder/some_file.rb:123:in `some_method_name'",
+                     "/another/path/foo.rb:1234:in `block (3 levels) run'"])
+
+    sample_env_hash = {
+      "SERVER_NAME"=>"localhost",
+      "REQUEST_METHOD"=>"GET",
+      "REQUEST_PATH"=>"/",
+      "PATH_INFO"=>"/",
+      "QUERY_STRING"=>"a=b&c=4945438",
+      "REQUEST_URI"=>"/?a=b&c=4945438",
+      "HTTP_VERSION"=>"HTTP/1.1",
+      "HTTP_HOST"=>"localhost:3000",
+      "HTTP_CONNECTION"=>"keep-alive",
+      "HTTP_CACHE_CONTROL"=>"max-age=0",
+      "HTTP_ACCEPT"=>"text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
+      "HTTP_USER_AGENT"=>"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_8_4) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/29.0.1547.22 Safari/537.36",
+      "HTTP_ACCEPT_ENCODING"=>"gzip,deflate,sdch",
+      "HTTP_ACCEPT_LANGUAGE"=>"en-US,en;q=0.8",
+      "HTTP_COOKIE"=>"cookieval",
+      "GATEWAY_INTERFACE"=>"CGI/1.2",
+      "SERVER_PORT"=>"3000",
+      "SERVER_PROTOCOL"=>"HTTP/1.1",
+      "SCRIPT_NAME"=>"",
+      "REMOTE_ADDR"=>"127.0.0.1"
+    }
+
+    expected_hash = {
+      hostName:    "localhost",
+      url:         "/",
+      httpMethod:  "GET",
+      iPAddress:   "127.0.0.1",
+      queryString: "[FILTERED]",
+      headers:     { "Version"=>"HTTP/1.1", "Host"=>"localhost:3000", "Connection"=>"keep-alive", "Cache-Control"=>"max-age=0", "Accept"=>"text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8", "User-Agent"=>"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_8_4) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/29.0.1547.22 Safari/537.36", "Accept-Encoding"=>"gzip,deflate,sdch", "Accept-Language"=>"en-US,en;q=0.8", "Cookie"=>"cookieval" },
+      form:        {},
+      rawData:     {}
+    }
+
+    details = @client.send(:build_payload_hash, e, sample_env_hash)[:details]
+
+    assert_equal expected_hash, details[:request]
+  end
+
+  def test_filter_payload_with_whitelist_being_false_does_not_filter_query_string
+    Raygun.configuration.filter_payload_with_whitelist = false
+    e = TestException.new("A test message")
+    e.set_backtrace(["/some/folder/some_file.rb:123:in `some_method_name'",
+                     "/another/path/foo.rb:1234:in `block (3 levels) run'"])
+
+    sample_env_hash = {
+      "SERVER_NAME"=>"localhost",
+      "REQUEST_METHOD"=>"GET",
+      "REQUEST_PATH"=>"/",
+      "PATH_INFO"=>"/",
+      "QUERY_STRING"=>"a=b&c=4945438",
+      "REQUEST_URI"=>"/?a=b&c=4945438",
+      "HTTP_VERSION"=>"HTTP/1.1",
+      "HTTP_HOST"=>"localhost:3000",
+      "HTTP_CONNECTION"=>"keep-alive",
+      "HTTP_CACHE_CONTROL"=>"max-age=0",
+      "HTTP_ACCEPT"=>"text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
+      "HTTP_USER_AGENT"=>"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_8_4) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/29.0.1547.22 Safari/537.36",
+      "HTTP_ACCEPT_ENCODING"=>"gzip,deflate,sdch",
+      "HTTP_ACCEPT_LANGUAGE"=>"en-US,en;q=0.8",
+      "HTTP_COOKIE"=>"cookieval",
+      "GATEWAY_INTERFACE"=>"CGI/1.2",
+      "SERVER_PORT"=>"3000",
+      "SERVER_PROTOCOL"=>"HTTP/1.1",
+      "SCRIPT_NAME"=>"",
+      "REMOTE_ADDR"=>"127.0.0.1"
+    }
+
+    expected_hash = {
+      hostName:    "localhost",
+      url:         "/",
+      httpMethod:  "GET",
+      iPAddress:   "127.0.0.1",
+      queryString: { "a" => "b", "c" => "4945438" },
+      headers:     { "Version"=>"HTTP/1.1", "Host"=>"localhost:3000", "Connection"=>"keep-alive", "Cache-Control"=>"max-age=0", "Accept"=>"text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8", "User-Agent"=>"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_8_4) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/29.0.1547.22 Safari/537.36", "Accept-Encoding"=>"gzip,deflate,sdch", "Accept-Language"=>"en-US,en;q=0.8", "Cookie"=>"cookieval" },
+      form:        {},
+      rawData:     {}
+    }
+
+    details = @client.send(:build_payload_hash, e, sample_env_hash)[:details]
+
+    assert_equal expected_hash, details[:request]
+  end
+
+  def test_filter_payload_with_whitelist_request_specific_keys
+    Raygun.configuration.filter_payload_with_whitelist = true
+    Raygun.configuration.whitelist_payload_shape = {
+      request: {
+        url: true,
+        httpMethod: true,
+        hostName: true
+      }
+    }
+
+    e = TestException.new("A test message")
+    e.set_backtrace(["/some/folder/some_file.rb:123:in `some_method_name'",
+                     "/another/path/foo.rb:1234:in `block (3 levels) run'"])
+
+    details = @client.send(:build_payload_hash, e, sample_env_hash)[:details]
+
+    expected_hash = {
+      hostName:    "localhost",
+      url:         "/",
+      httpMethod:  "POST",
+      iPAddress:   "[FILTERED]",
+      queryString: "[FILTERED]",
+      headers:     "[FILTERED]",
+      form:        "[FILTERED]",
+      rawData:     "[FILTERED]"
+    }
+
+    assert_equal expected_hash, details[:request]
+  end
+
+
+  private
+
+  def sample_env_hash
+    {
+      "SERVER_NAME"=>"localhost",
+      "REQUEST_METHOD"=>"POST",
+      "REQUEST_PATH"=>"/",
+      "PATH_INFO"=>"/",
+      "QUERY_STRING"=>"",
+      "REQUEST_URI"=>"/",
+      "HTTP_VERSION"=>"HTTP/1.1",
+      "HTTP_HOST"=>"localhost:3000",
+      "HTTP_CONNECTION"=>"keep-alive",
+      "HTTP_CACHE_CONTROL"=>"max-age=0",
+      "HTTP_ACCEPT"=>"text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
+      "HTTP_USER_AGENT"=>"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_8_4) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/29.0.1547.22 Safari/537.36",
+      "HTTP_ACCEPT_ENCODING"=>"gzip,deflate,sdch",
+      "HTTP_ACCEPT_LANGUAGE"=>"en-US,en;q=0.8",
+      "HTTP_COOKIE"=>"cookieval",
+      "GATEWAY_INTERFACE"=>"CGI/1.2",
+      "SERVER_PORT"=>"3000",
+      "SERVER_PROTOCOL"=>"HTTP/1.1",
+      "SCRIPT_NAME"=>"",
+      "REMOTE_ADDR"=>"127.0.0.1"
+    }
+  end
+
 end

data/test/unit/configuration_test.rb

@@ -76,4 +76,20 @@ class ConfigurationTest < Raygun::UnitTest
     Raygun.configuration.filter_parameters = nil
   end
 
+  def test_filter_payload_with_whitelist_default
+    assert_equal(false, Raygun.configuration.filter_payload_with_whitelist)
+  end
+
+  def test_setting_whitelist_payload_keys_to_proc
+    Raygun.setup do |config|
+      config.whitelist_payload_shape do |hash|
+        # No-op
+      end
+    end
+
+    assert Raygun.configuration.whitelist_payload_shape.is_a?(Proc)
+    ensure
+      Raygun.configuration.whitelist_payload_shape = nil
+  end
+
 end

data/test/unit/raygun_test.rb

@@ -0,0 +1,12 @@
+# -*- coding: utf-8 -*-
+require_relative "../test_helper.rb"
+require 'stringio'
+
+class RaygunTest < Raygun::UnitTest
+
+  def test_raygun_is_not_configured_with_no_api_key
+    Raygun.configuration.api_key = nil
+    assert !Raygun.configured?
+  end
+
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: raygun4ruby
 version: !ruby/object:Gem::Version
-  version: 1.1.12
+  version: 1.2.0
 platform: ruby
 authors:
 - Mindscape
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-02-06 00:00:00.000000000 Z
+date: 2017-03-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: httparty
@@ -185,6 +185,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: Ruby Adapter for Raygun.io
 email:
 - hello@raygun.io
@@ -194,6 +208,7 @@ extra_rdoc_files: []
 files:
 - ".gitignore"
 - ".travis.yml"
+- CHANGELOG.md
 - Gemfile
 - LICENSE.txt
 - README.md
@@ -206,6 +221,7 @@ files:
 - lib/raygun/middleware/rack_exception_interceptor.rb
 - lib/raygun/middleware/rails_insert_affected_user.rb
 - lib/raygun/railtie.rb
+- lib/raygun/services/apply_whitelist_filter_to_payload.rb
 - lib/raygun/sidekiq.rb
 - lib/raygun/testable.rb
 - lib/raygun/version.rb
@@ -213,11 +229,13 @@ files:
 - lib/resque/failure/raygun.rb
 - lib/tasks/raygun.tasks
 - raygun4ruby.gemspec
+- specs/services/apply_whitelist_filter_to_payload_spec.rb
 - test/integration/client_test.rb
 - test/test_helper.rb
 - test/unit/client_test.rb
 - test/unit/configuration_test.rb
 - test/unit/rails_insert_affected_user_test.rb
+- test/unit/raygun_test.rb
 - test/unit/resque_failure_test.rb
 - test/unit/sidekiq_failure_test.rb
 homepage: http://raygun.io
@@ -240,7 +258,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 2.5.1
 signing_key: 
 specification_version: 4
 summary: This gem provides support for Ruby and Ruby on Rails for the Raygun.io error
@@ -251,5 +269,6 @@ test_files:
 - test/unit/client_test.rb
 - test/unit/configuration_test.rb
 - test/unit/rails_insert_affected_user_test.rb
+- test/unit/raygun_test.rb
 - test/unit/resque_failure_test.rb
 - test/unit/sidekiq_failure_test.rb