raygun4ruby 1.2.1 → 1.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 80ada759d3d4ae7ad92f5228c4d802fe43f77280
-  data.tar.gz: eda49a02950403ce1d8db66a379848deb9de014b
+  metadata.gz: 177fe25eed9a04d4924bf9a49ce89e521cdc3af3
+  data.tar.gz: 4b1ee81e75e37b688a24bb9bc18a8ac187eb2e90
 SHA512:
-  metadata.gz: 8f39b4a45ec2e353cd1520f5dd688a40b7e39fbce62fac93c23b88a96cd8d7ee811c5f596bf0dd78ff31e61be3fc3e2920ca8d24ea7450b290da2d10c9045be7
-  data.tar.gz: 83576e29d1e5156219fadfa97924fcedb49543a6597ef79f9532c188a0cf45e4653cee43ed9417d9cdfd4c784dffcfdb5f2d7a6261e220b2b33c2c024ca58f26
+  metadata.gz: 240b3595f0525d734fd067e33db5f21a0f20e3c47901c44c019fb046d35c4566fe685e48343721049507afc711fc30364aa11bffb1d218526a1d28391db06f14
+  data.tar.gz: c9054cb36202bab19b695cc08de7c8e48cff4c50cd1e5fa911f9aac217076a0e08cf6984bb2429ffe79d0f0c8c9d6f1e486daf9b4b80de02dea4ae2d767acb09

data/CHANGELOG.md

@@ -1,3 +1,12 @@
+## 1.3.0 (10/03/2017)
+
+Features:
+  - Improve affected user handling to let you specify all Raygun parameters, identifier, email, first name, full name and uuid. See [README.md](https://github.com/MindscapeHQ/raygun4ruby#affected-user-tracking) for details
+  - Pass a user object as the third parameter to `Raygun.track_exception` to have affected user tracking for manually tracked exceptions, see the above link for more information on configuring this
+  - If the exception instance responds to `:raygun_custom_data` that method will be called and the return value merged into the `custom_data` hash sent to Raygun. For convenience a `Raygun::Error` class is provided that takes this custom data as a second argument
+  - Allowed `Configuration.custom_data` to be set to a proc to allow a global custom data hook for all exceptions. It is passed as arguments the exception and the environment hash
+  - Added `Configuration.debug` to enable logging the reason why an exception was not reported
+
 ## 1.2.1 (09/03/2017)
 
 Bugfixes:

data/README.md

@@ -74,6 +74,13 @@ rescue Exception => e
   Raygun.track_exception(e)
 end
 
+# You may also pass a user object as the third argument to allow affected user tracking, like so
+begin
+  # your lovely code here
+rescue Exception => e
+  # The second argument is the request environment variables
+  Raygun.track_exception(e, {}, user)
+end
 ```
 
 You can also pass a Hash as the second parameter to `track_exception`. It should look like a [Rack Env Hash](http://rack.rubyforge.org/doc/SPEC.html)
@@ -151,6 +158,26 @@ end
 
 ```
 
+Custom data can also be specified globally either by setting `config.custom_data` to a hash
+
+```ruby
+Raygun.setup do |config|
+  config.api_key = "YOUR_RAYGUN_API_KEY"
+  config.custom_data = {custom_data: 'goes here'}
+end
+```
+
+or to a proc, which gets passed the exception and environment hash
+
+```ruby
+Raygun.setup do |config|
+  config.api_key = "YOUR_RAYGUN_API_KEY"
+  config.custom_data do |e, env|
+    {message: e.message, server: env["SERVER_NAME"]}
+  end
+end
+```
+
 ### Ignoring Some Errors
 
 You can ignore certain types of Exception using the `ignore` option in the setup block, like so:
@@ -199,21 +226,30 @@ end
 
 Raygun can now track how many users have been affected by an error.
 
-By default, Raygun looks for a method called `current_user` on your controller, and calls either `email`, `username` or `id` on the object returned by that method.
+By default, Raygun looks for a method called `current_user` on your controller, and it will populate the user's information based on a default method name mapping.
 
-You can customize those method names in your configuration block:
+(e.g Raygun will call `email` to populate the user's email, and `first_name` for the user's first name)
+
+You can inspect and customize this mapping using `config.affected_user_mapping`, like so:
 
 ```ruby
 Raygun.setup do |config|
   config.api_key = "MY_SWEET_API_KEY"
   config.affected_user_method = :my_current_user # `current_user` by default
-  config.affected_user_identifier_methods << :login # `[ :email, :username, :id ]` by default - will use the first that works
+  # To augment the defaults with your unique methods you can do the following
+  config.affected_user_mapping = Raygun::AffectedUser::DEFAULT_MAPPING.merge({
+    identifier: :some_custom_unique_identifier,
+    # If you set the key to a proc it will be passed the user object and you can construct the value your self
+    full_name: ->(user) { "#{user.first_name} #{user.last_name}" }
+  })
 end
 ```
 
+To see the defaults check out [affected_user.rb](https://github.com/MindscapeHQ/raygun4ruby/tree/master/lib/raygun/affected_user.rb)
+
 If you're using Rails, most authentication systems will have this method set and you should be good to go.
 
-The count of unique affected users will appear on the error group in the Raygun dashboard. If your user has an `email` method, and that email has a Gravatars associated, you will also see your user's avatar.
+The count of unique affected users will appear on the error group in the Raygun dashboard. If your user has an `Email` attribute, and that email has a Gravatar associated with that address, you will also see your user's avatar.
 
 If you wish to keep it anonymous, you could set this identifier to something like `SecureRandom.uuid` and store that in a cookie, like so:
 

data/lib/raygun.rb

@@ -5,17 +5,20 @@ require "socket"
 require "rack"
 require "ostruct"
 
+begin
+  require "pry"
+rescue LoadError
+end
+
 require "raygun/version"
 require "raygun/configuration"
 require "raygun/client"
 require "raygun/middleware/rack_exception_interceptor"
 require "raygun/testable"
+require "raygun/error"
+require "raygun/affected_user"
 require "raygun/services/apply_whitelist_filter_to_payload"
 require "raygun/railtie" if defined?(Rails)
-begin
-  require "pry"
-rescue LoadError
-end
 
 module Raygun
 
@@ -46,10 +49,10 @@ module Raygun
       !!configuration.api_key
     end
 
-    def track_exception(exception_instance, env = {}, retry_count = 1)
+    def track_exception(exception_instance, env = {}, user = nil, retry_count = 1)
       if should_report?(exception_instance)
         log("[Raygun] Tracking Exception...")
-        Client.new.track_exception(exception_instance, env)
+        Client.new.track_exception(exception_instance, env, user)
       end
     rescue Exception => e
       if configuration.failsafe_logger
@@ -63,7 +66,7 @@ module Raygun
         env[:custom_data] ||= {}
         env[:custom_data].merge!(original_stacktrace: exception_instance.backtrace)
 
-        track_exception(new_exception, env, retry_count - 1)
+        track_exception(new_exception, env, user, retry_count - 1)
       else
         raise e
       end
@@ -83,17 +86,38 @@ module Raygun
       configuration.failsafe_logger.info(message)
     end
 
+    def deprecation_warning(message)
+      if defined?(ActiveSupport::Deprecation)
+        ActiveSupport::Deprecation.warn(message)
+      else
+        puts message
+      end
+    end
+
     private
 
-      def print_api_key_warning
-        $stderr.puts(NO_API_KEY_MESSAGE)
+    def print_api_key_warning
+      $stderr.puts(NO_API_KEY_MESSAGE)
+    end
+
+    def should_report?(exception)
+      if configuration.silence_reporting
+        if configuration.debug
+          log('[Raygun] skipping reporting because Configuration.silence_reporting is enabled')
+        end
+
+        return false
       end
 
-      def should_report?(exception)
-        return false if configuration.silence_reporting
-        return false if configuration.ignore.flatten.include?(exception.class.to_s)
-        true
+      if configuration.ignore.flatten.include?(exception.class.to_s)
+        if configuration.debug
+          log("[Raygun] skipping reporting of exception #{exception.class} because it is in the ignore list")
+        end
+
+        return false
       end
 
+      true
+    end
   end
 end

data/lib/raygun/affected_user.rb

@@ -0,0 +1,59 @@
+module Raygun
+  class AffectedUser
+
+    DEFAULT_MAPPING = {
+      identifier: [ :id, :username ],
+      email:      :email,
+      full_name:  [ :full_name, :name ],
+      first_name: :first_name,
+      uuid:       :uuid
+    }.freeze
+    SUPPORTED_ATTRIBUTES = DEFAULT_MAPPING.keys.freeze
+    NAME_TO_RAYGUN_NAME_MAPPING = {
+      identifier: :Identifier,
+      email: :Email,
+      full_name: :FullName,
+      first_name: :FirstName,
+      uuid: :UUID
+    }.freeze
+
+    class << self
+      def information_hash(user_object)
+        if user_object.nil? || user_object.is_a?(String)
+          handle_anonymous_user(user_object)
+        else
+          handle_known_user(user_object)
+        end
+      end
+
+      private
+
+      def handle_anonymous_user(user_object)
+        result = { IsAnonymous: true }
+        result[:Identifier] = user_object unless user_object.nil?
+        result
+      end
+
+      def handle_known_user(user_object)
+        SUPPORTED_ATTRIBUTES.reduce({ IsAnonymous: false }) do |result, attribute|
+          mapping = Raygun.configuration.affected_user_mapping
+          method = mapping[attribute]
+
+          value = if method.is_a? Proc
+                    method.call(user_object)
+                  else
+                    attributes = Array(method)
+                    attribute_to_use = attributes.select do |attr|
+                      user_object.respond_to?(attr, true)
+                    end.first
+
+                    user_object.send(attribute_to_use) unless attribute_to_use == nil
+                  end
+
+          result[NAME_TO_RAYGUN_NAME_MAPPING[attribute]] = value unless value == nil
+          result
+        end
+      end
+    end
+  end
+end

data/lib/raygun/client.rb

@@ -23,8 +23,8 @@ module Raygun
       Raygun.configuration.api_key || print_api_key_warning
     end
 
-    def track_exception(exception_instance, env = {})
-      create_entry(build_payload_hash(exception_instance, env))
+    def track_exception(exception_instance, env = {}, user = nil)
+      create_entry(build_payload_hash(exception_instance, env, user))
     end
 
     private
@@ -141,8 +141,14 @@ module Raygun
       end
 
       # see http://raygun.io/raygun-providers/rest-json-api?v=1
-      def build_payload_hash(exception_instance, env = {})
+      def build_payload_hash(exception_instance, env = {}, user = nil)
         custom_data = filter_custom_data(env) || {}
+        exception_custom_data = if exception_instance.respond_to?(:raygun_custom_data)
+                                  exception_instance.raygun_custom_data
+                                else
+                                  {}
+                                end
+
         tags = env.delete(:tags) || []
 
         if rails_env
@@ -153,19 +159,31 @@ module Raygun
 
         grouping_key = env.delete(:grouping_key)
 
+        configuration_custom_data = Raygun.configuration.custom_data
+        configured_custom_data = if configuration_custom_data.is_a?(Proc)
+                                  configuration_custom_data.call(exception_instance, env)
+                                 else
+                                  configuration_custom_data
+                                 end
+
         error_details = {
             machineName:    hostname,
             version:        version,
             client:         client_details,
             error:          error_details(exception_instance),
-            userCustomData: Raygun.configuration.custom_data.merge(custom_data),
+            userCustomData: exception_custom_data.merge(custom_data).merge(configured_custom_data),
             tags:           Raygun.configuration.tags.concat(tags).compact.uniq,
             request:        request_information(env)
         }
 
         error_details.merge!(groupingKey: grouping_key) if grouping_key
 
-        error_details.merge!(user: user_information(env)) if affected_user_present?(env)
+        user_details = if affected_user_present?(env)
+                         user_information(env)
+                       elsif user != nil
+                         AffectedUser.information_hash(user)
+                       end
+        error_details.merge!(user: user_details) unless user_details == nil
 
         if Raygun.configuration.filter_payload_with_whitelist
           error_details = filter_payload_with_whitelist(error_details)

data/lib/raygun/configuration.rb

@@ -11,6 +11,17 @@ module Raygun
       end
     end
 
+    def self.proc_config_option(name)
+      define_method(name) do |&block|
+        set_value(name, block) unless block == nil
+        read_value(name)
+      end
+
+      define_method("#{name}=") do |value|
+        set_value(name, value)
+      end
+    end
+
     # Your Raygun API Key - this can be found on your dashboard at Raygun.io
     config_option :api_key
 
@@ -21,7 +32,7 @@ module Raygun
     config_option :version
 
     # Custom Data to send with each exception
-    config_option :custom_data
+    proc_config_option :custom_data
 
     # Tags to send with each exception
     config_option :tags
@@ -38,21 +49,24 @@ module Raygun
     # Which controller method should we call to find out the affected user?
     config_option :affected_user_method
 
-    # Which methods should we try on the affected user object in order to get an identifier
-    config_option :affected_user_identifier_methods
+    # Mapping of methods for the affected user object - which methods should we call for user information
+    config_option :affected_user_mapping
 
     # Which parameter keys should we filter out by default?
-    config_option :filter_parameters
+    proc_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
+    proc_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
 
+    # Set this to true to have raygun4ruby log the reason why it skips reporting an exception
+    config_option :debug
+
     # Exception classes to ignore by default
     IGNORE_DEFAULT = ['ActiveRecord::RecordNotFound',
                       'ActionController::RoutingError',
@@ -96,11 +110,12 @@ module Raygun
         tags:                             [],
         enable_reporting:                 true,
         affected_user_method:             :current_user,
-        affected_user_identifier_methods: [ :email, :username, :id ],
+        affected_user_mapping:            AffectedUser::DEFAULT_MAPPING,
         filter_parameters:                DEFAULT_FILTER_PARAMETERS,
         filter_payload_with_whitelist:    false,
         whitelist_payload_shape:          DEFAULT_WHITELIST_PAYLOAD_SHAPE,
-        proxy_settings:                   {}
+        proxy_settings:                   {},
+        debug: false
       })
     end
 
@@ -120,14 +135,9 @@ module Raygun
       self.enable_reporting = !value
     end
 
-    def filter_parameters(&filter_proc)
-      set_value(:filter_parameters, filter_proc) if block_given?
-      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)
+    def affected_user_identifier_methods
+      Raygun.deprecation_warning("Please note: You should now user config.affected_user_method_mapping.Identifier instead of config.affected_user_identifier_methods")
+      read_value(:affected_user_method_mapping).Identifier
     end
 
     private

data/lib/raygun/error.rb

@@ -0,0 +1,10 @@
+module Raygun
+  class Error < StandardError
+    attr_reader :raygun_custom_data
+
+    def initialize(message, raygun_custom_data = {})
+      super(message)
+      @raygun_custom_data = raygun_custom_data
+    end
+  end
+end

data/lib/raygun/middleware/rails_insert_affected_user.rb

@@ -8,24 +8,19 @@ module Raygun
       end
 
       def call(env)
-        response = @app.call(env)
+        @app.call(env)
       rescue Exception => exception
-        if (controller = env["action_controller.instance"]) && controller.respond_to?(Raygun.configuration.affected_user_method, true)
-          user = controller.send(Raygun.configuration.affected_user_method)
+        controller = env["action_controller.instance"]
+        affected_user_method = Raygun.configuration.affected_user_method
 
-          if user
-            identifier = if (m = Raygun.configuration.affected_user_identifier_methods.detect { |m| user.respond_to?(m) })
-              user.send(m)
-            else
-              user
-            end
+        if controller && controller.respond_to?(affected_user_method, true)
+          user = controller.send(affected_user_method)
 
-            env["raygun.affected_user"] = { :identifier => identifier }
-          end
+          env["raygun.affected_user"] = Raygun::AffectedUser.information_hash(user)
         end
+
         raise exception
       end
-
     end
   end
 end

data/lib/raygun/version.rb

@@ -1,3 +1,3 @@
 module Raygun
-  VERSION = "1.2.1"
+  VERSION = "1.3.0"
 end