raygun4ruby 3.1.1 → 3.2.4

data/lib/raygun/affected_user.rb

@@ -1,59 +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
+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/breadcrumbs.rb

@@ -1,34 +1,34 @@
-module Raygun
-  module Breadcrumbs
-    BREADCRUMB_LEVELS = [
-      :debug,
-      :info,
-      :warning,
-      :error,
-      :fatal
-    ]
-
-    def record_breadcrumb(
-        message: nil,
-        category: '',
-        level: :info,
-        timestamp: Time.now.utc.to_i,
-        metadata: {},
-        class_name: nil,
-        method_name: nil,
-        line_number: nil
-    )
-      class_name = class_name || self.class.name
-      Raygun::Breadcrumbs::Store.record(
-        message: message,
-        category: category,
-        level: level,
-        timestamp: timestamp,
-        metadata: metadata,
-        class_name: class_name,
-        method_name: method_name,
-        line_number: line_number,
-      )
-    end
-  end
-end
+module Raygun
+  module Breadcrumbs
+    BREADCRUMB_LEVELS = [
+      :debug,
+      :info,
+      :warning,
+      :error,
+      :fatal
+    ]
+
+    def record_breadcrumb(
+        message: nil,
+        category: '',
+        level: :info,
+        timestamp: Time.now.utc.to_i,
+        metadata: {},
+        class_name: nil,
+        method_name: nil,
+        line_number: nil
+    )
+      class_name = class_name || self.class.name
+      Raygun::Breadcrumbs::Store.record(
+        message: message,
+        category: category,
+        level: level,
+        timestamp: timestamp,
+        metadata: metadata,
+        class_name: class_name,
+        method_name: method_name,
+        line_number: line_number,
+      )
+    end
+  end
+end

data/lib/raygun/breadcrumbs/breadcrumb.rb

@@ -1,30 +1,34 @@
-module Raygun
-  module Breadcrumbs
-    class Breadcrumb
-      ATTRIBUTES = [
-        :message, :category, :metadata, :class_name,
-        :method_name, :line_number, :timestamp, :level,
-        :type
-      ]
-      attr_accessor(*ATTRIBUTES)
-
-      def build_payload
-        payload = {
-          message: message,
-          category: category,
-          level: Breadcrumbs::BREADCRUMB_LEVELS.index(level),
-          CustomData: metadata,
-          timestamp: timestamp,
-          type: type
-        }
-
-        payload[:location] = "#{class_name}:#{method_name}" unless class_name == nil
-        payload[:location] += ":#{line_number}" if payload.has_key?(:location) && line_number != nil
-
-        Hash[payload.select do |k, v|
-          v != nil
-        end]
-      end
-    end
-  end
-end
+module Raygun
+  module Breadcrumbs
+    class Breadcrumb
+      ATTRIBUTES = [
+        :message, :category, :metadata, :class_name,
+        :method_name, :line_number, :timestamp, :level,
+        :type
+      ]
+      attr_accessor(*ATTRIBUTES)
+
+      def build_payload
+        payload = {
+          message: message,
+          category: category,
+          level: Breadcrumbs::BREADCRUMB_LEVELS.index(level),
+          CustomData: metadata,
+          timestamp: timestamp,
+          type: type
+        }
+
+        payload[:location] = "#{class_name}:#{method_name}" unless class_name == nil
+        payload[:location] += ":#{line_number}" if payload.has_key?(:location) && line_number != nil
+
+        Hash[payload.select do |k, v|
+          v != nil
+        end]
+      end
+
+      def size
+        return message.length + 100
+      end
+    end
+  end
+end

data/lib/raygun/breadcrumbs/store.rb

@@ -1,76 +1,86 @@
-require_relative 'breadcrumb'
-
-module Raygun
-  module Breadcrumbs
-    class Store
-      def self.initialize
-        Thread.current[:breadcrumbs] ||= []
-      end
-
-      def self.clear
-        Thread.current[:breadcrumbs] = nil
-      end
-
-      def self.stored
-        Thread.current[:breadcrumbs]
-      end
-
-      def self.record(
-        message: nil,
-        category: '',
-        level: :info,
-        timestamp: Time.now.utc.to_i,
-        metadata: {},
-        class_name: nil,
-        method_name: nil,
-        line_number: nil
-      )
-        raise ArgumentError.new('missing keyword: message') if message == nil
-        crumb = Breadcrumb.new
-
-        crumb.message = message
-        crumb.category = category
-        crumb.level = level
-        crumb.metadata = metadata
-        crumb.timestamp = timestamp
-        crumb.type = 'manual'
-
-        caller = caller_locations[1]
-        crumb.class_name = class_name
-        crumb.method_name = method_name || caller.label
-        crumb.line_number = line_number || caller.lineno
-
-        Thread.current[:breadcrumbs] << crumb if should_record?(crumb)
-      end
-
-      def self.any?
-        stored != nil && stored.length > 0
-      end
-
-      private
-
-      def self.should_record?(crumb)
-        if stored.nil?
-          if Raygun.configuration.debug
-            Raygun.log('[Raygun.breadcrumbs] store is uninitialized while breadcrumb is being recorded, discarding breadcrumb')
-          end
-
-          return false
-        end
-
-        levels = Raygun::Breadcrumbs::BREADCRUMB_LEVELS
-
-        active_level = levels.index(Raygun.configuration.breadcrumb_level)
-        crumb_level = levels.index(crumb.level) || -1
-
-        discard = crumb_level < active_level
-
-        if discard && Raygun.configuration.debug
-          Raygun.log("[Raygun.breadcrumbs] discarding breadcrumb because #{crumb.level} is below active breadcrumb level (#{Raygun.configuration.breadcrumb_level})")
-        end
-
-        !discard
-      end
-    end
-  end
-end
+require_relative 'breadcrumb'
+
+module Raygun
+  module Breadcrumbs
+    class Store
+      def self.initialize
+        Thread.current[:breadcrumbs] ||= []
+      end
+
+      def self.clear
+        Thread.current[:breadcrumbs] = nil
+      end
+
+      def self.stored
+        Thread.current[:breadcrumbs]
+      end
+
+      def self.record(
+        message: nil,
+        category: '',
+        level: :info,
+        timestamp: Time.now.utc.to_i,
+        metadata: {},
+        class_name: nil,
+        method_name: nil,
+        line_number: nil
+      )
+        raise ArgumentError.new('missing keyword: message') if message == nil
+        crumb = Breadcrumb.new
+
+        crumb.message = message
+        crumb.category = category
+        crumb.level = level
+        crumb.metadata = metadata
+        crumb.timestamp = timestamp
+        crumb.type = 'manual'
+
+        caller = caller_locations[1]
+        crumb.class_name = class_name
+        crumb.method_name = method_name || caller.label
+        crumb.line_number = line_number || caller.lineno
+
+        Thread.current[:breadcrumbs] << crumb if should_record?(crumb)
+      end
+
+      def self.any?
+        stored != nil && stored.length > 0
+      end
+
+      def self.take_until_size(size)
+        breadcrumb_size = 0
+
+        stored.reverse.take_while do |crumb|
+          breadcrumb_size += crumb.size
+
+          breadcrumb_size < size
+        end.reverse
+      end
+
+      private
+
+      def self.should_record?(crumb)
+        if stored.nil?
+          if Raygun.configuration.debug
+            Raygun.log('[Raygun.breadcrumbs] store is uninitialized while breadcrumb is being recorded, discarding breadcrumb')
+          end
+
+          return false
+        end
+
+        levels = Raygun::Breadcrumbs::BREADCRUMB_LEVELS
+
+        active_level = levels.index(Raygun.configuration.breadcrumb_level)
+        crumb_level = levels.index(crumb.level) || -1
+
+        discard = crumb_level < active_level
+
+        if discard && Raygun.configuration.debug
+          Raygun.log("[Raygun.breadcrumbs] discarding breadcrumb because #{crumb.level} is below active breadcrumb level (#{Raygun.configuration.breadcrumb_level})")
+        end
+
+        !discard
+      end
+    end
+  end
+end

data/lib/raygun/client.rb

@@ -1,302 +1,305 @@
-module Raygun
-  # client for the Raygun REST APIv1
-  # as per http://raygun.io/raygun-providers/rest-json-api?v=1
-  class Client
-
-    ENV_IP_ADDRESS_KEYS = %w(action_dispatch.remote_ip raygun.remote_ip REMOTE_ADDR)
-    NO_API_KEY_MESSAGE  = "[RAYGUN] Just a note, you've got no API Key configured, which means we can't report exceptions. Specify your Raygun API key using Raygun#setup (find yours at https://app.raygun.io)"
-
-    include HTTParty
-
-    def initialize
-      @api_key = require_api_key
-      @headers = {
-        "X-ApiKey" => @api_key
-      }
-
-      enable_http_proxy if Raygun.configuration.proxy_settings[:address]
-      self.class.base_uri Raygun.configuration.api_url
-      self.class.default_timeout(Raygun.configuration.error_report_send_timeout)
-    end
-
-    def require_api_key
-      Raygun.configuration.api_key || print_api_key_warning
-    end
-
-    def track_exception(exception_instance, env = {}, user = nil)
-      create_entry(build_payload_hash(exception_instance, env, user))
-    end
-
-    private
-
-      def enable_http_proxy
-        self.class.http_proxy(Raygun.configuration.proxy_settings[:address],
-                              Raygun.configuration.proxy_settings[:port] || "80",
-                              Raygun.configuration.proxy_settings[:username],
-                              Raygun.configuration.proxy_settings[:password])
-      end
-
-      def client_details
-        {
-          name:      Raygun::CLIENT_NAME,
-          version:   Raygun::VERSION,
-          clientUrl: Raygun::CLIENT_URL
-        }
-      end
-
-      def error_details(exception)
-        details = {
-          className:  exception.class.to_s,
-          message:    exception.message.to_s.encode('UTF-16', :undef => :replace, :invalid => :replace).encode('UTF-8'),
-          stackTrace: (exception.backtrace || []).map { |line| stack_trace_for(line) },
-        }
-
-        details.update(innerError: error_details(exception.cause)) if exception.respond_to?(:cause) && exception.cause
-
-        details
-      end
-
-      def stack_trace_for(line)
-        # see http://www.ruby-doc.org/core-2.0/Exception.html#method-i-backtrace
-        file_name, line_number, method = line.split(":")
-        {
-          lineNumber: line_number,
-          fileName:   file_name,
-          methodName: method ? method.gsub(/^in `(.*?)'$/, "\\1") : "(none)"
-        }
-      end
-
-      def hostname
-        Socket.gethostname
-      end
-
-      def version
-        Raygun.configuration.version
-      end
-
-      def user_information(env)
-        env["raygun.affected_user"]
-      end
-
-      def affected_user_present?(env)
-        !!env["raygun.affected_user"]
-      end
-
-      def rack_env
-        ENV["RACK_ENV"]
-      end
-
-      def rails_env
-        ENV["RAILS_ENV"]
-      end
-
-      def request_information(env)
-        Raygun.log('retrieving request information')
-
-        return {} if env.nil? || env.empty?
-        {
-          hostName:    env["SERVER_NAME"],
-          url:         env["PATH_INFO"],
-          httpMethod:  env["REQUEST_METHOD"],
-          iPAddress:   "#{ip_address_from(env)}",
-          queryString: Rack::Utils.parse_nested_query(env["QUERY_STRING"]),
-          headers:     headers(env),
-          form:        form_params(env),
-          rawData:     raw_data(env)
-        }
-      end
-
-      def headers(rack_env)
-        rack_env.select { |k, v| k.to_s.start_with?("HTTP_") }.inject({}) do |hsh, (k, v)|
-          hsh[normalize_raygun_header_key(k)] = v
-          hsh
-        end
-      end
-
-      def normalize_raygun_header_key(key)
-        key.sub(/^HTTP_/, '')
-           .sub(/_/, ' ')
-           .split.map(&:capitalize).join(' ')
-           .sub(/ /, '-')
-      end
-
-      def form_params(env)
-        Raygun.log('retrieving form params')
-
-        params = action_dispatch_params(env) || rack_params(env) || {}
-        filter_params_with_blacklist(params, env["action_dispatch.parameter_filter"])
-      end
-
-      def action_dispatch_params(env)
-        env["action_dispatch.request.parameters"]
-      end
-
-      def rack_params(env)
-        request = Rack::Request.new(env)
-        request.params if env["rack.input"]
-      end
-
-      def raw_data(rack_env)
-        Raygun.log('retrieving raw data')
-        request = Rack::Request.new(rack_env)
-
-        return unless Raygun.configuration.record_raw_data
-        return if request.get?
-        Raygun.log('passed raw_data checks')
-
-        input = rack_env['rack.input']
-
-        if input && !request.form_data?
-          input.rewind
-
-          body = input.read(4096) || ''
-          input.rewind
-
-          body
-        else
-          {}
-        end
-      end
-
-      def filter_custom_data(env)
-        params = env.delete(:custom_data) || {}
-        filter_params_with_blacklist(params, env["action_dispatch.parameter_filter"])
-      end
-
-      # see http://raygun.io/raygun-providers/rest-json-api?v=1
-      def build_payload_hash(exception_instance, env = {}, user = nil)
-        Raygun.log('building payload hash')
-        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
-          tags << rails_env
-        else
-          tags << rack_env
-        end
-
-        configuration_tags = []
-        if Raygun.configuration.tags.is_a?(Proc)
-          configuration_tags = Raygun.configuration.tags.call(exception_instance, env)
-        else
-          configuration_tags = Raygun.configuration.tags
-        end
-
-        Raygun.log('set tags')
-
-        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
-
-        Raygun.log('set custom data')
-
-        error_details = {
-            machineName:    hostname,
-            version:        version,
-            client:         client_details,
-            error:          error_details(exception_instance),
-            userCustomData: exception_custom_data.merge(custom_data).merge(configured_custom_data),
-            tags:           configuration_tags.concat(tags).compact.uniq,
-            request:        request_information(env),
-            environment:    {
-              utcOffset: Time.now.utc_offset / 3600
-            }
-        }
-        store = ::Raygun::Breadcrumbs::Store
-        error_details[:breadcrumbs] = store.stored.map(&:build_payload) if store.any?
-
-        Raygun.log('set details and breadcrumbs')
-
-        error_details.merge!(groupingKey: grouping_key) if grouping_key
-
-        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
-
-        Raygun.log('set user details')
-
-        if Raygun.configuration.filter_payload_with_whitelist
-          Raygun.log('filtering payload with whitelist')
-          error_details = filter_payload_with_whitelist(error_details)
-        end
-
-        {
-          occurredOn: Time.now.utc.iso8601,
-          details:    error_details
-        }
-      end
-
-      def create_entry(payload_hash)
-        Raygun.log('sending payload to api')
-
-        self.class.post(
-          "/entries",
-          verify_peer: true,
-          verify: true,
-          headers: @headers,
-          body: JSON.generate(payload_hash),
-        )
-      end
-
-      def filter_params_with_blacklist(params_hash = {}, extra_filter_keys = nil)
-        filter_parameters = Raygun.configuration.filter_parameters
-
-        if filter_parameters.is_a? Proc
-          filter_parameters.call(params_hash)
-        else
-          filter_keys = (Array(extra_filter_keys) + filter_parameters).map(&:to_s)
-
-          filter_params_with_array(params_hash, filter_keys)
-        end
-      end
-
-      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)
-        # Recursive filtering of (nested) hashes
-        (params_hash || {}).inject({}) do |result, (k, v)|
-          result[k] = case v
-          when Hash
-            filter_params_with_array(v, filter_keys)
-          else
-            filter_keys.any? { |fk| /#{fk}/i === k.to_s } ? "[FILTERED]" : v
-          end
-          result
-        end
-      end
-
-      def ip_address_from(env_hash)
-        ENV_IP_ADDRESS_KEYS.each do |key_to_try|
-          return env_hash[key_to_try] unless env_hash[key_to_try].nil? || env_hash[key_to_try] == ""
-        end
-        "(Not Available)"
-      end
-
-      def print_api_key_warning
-        $stderr.puts(NO_API_KEY_MESSAGE)
-      end
-  end
-end
+module Raygun
+  # client for the Raygun REST APIv1
+  # as per https://raygun.com/documentation/product-guides/crash-reporting/api/
+  class Client
+
+    ENV_IP_ADDRESS_KEYS = %w(action_dispatch.remote_ip raygun.remote_ip REMOTE_ADDR)
+    NO_API_KEY_MESSAGE  = "[RAYGUN] Just a note, you've got no API Key configured, which means we can't report exceptions. Specify your Raygun API key using Raygun#setup (find yours at https://app.raygun.com)"
+    MAX_BREADCRUMBS_SIZE = 100_000
+
+    include HTTParty
+
+    def initialize
+      @api_key = require_api_key
+      @headers = {
+        "X-ApiKey" => @api_key
+      }
+
+      enable_http_proxy if Raygun.configuration.proxy_settings[:address]
+      self.class.base_uri Raygun.configuration.api_url
+      self.class.default_timeout(Raygun.configuration.error_report_send_timeout)
+    end
+
+    def require_api_key
+      Raygun.configuration.api_key || print_api_key_warning
+    end
+
+    def track_exception(exception_instance, env = {}, user = nil)
+      create_entry(build_payload_hash(exception_instance, env, user))
+    end
+
+    private
+
+      def enable_http_proxy
+        self.class.http_proxy(Raygun.configuration.proxy_settings[:address],
+                              Raygun.configuration.proxy_settings[:port] || "80",
+                              Raygun.configuration.proxy_settings[:username],
+                              Raygun.configuration.proxy_settings[:password])
+      end
+
+      def client_details
+        {
+          name:      Raygun::CLIENT_NAME,
+          version:   Raygun::VERSION,
+          clientUrl: Raygun::CLIENT_URL
+        }
+      end
+
+      def error_details(exception)
+        details = {
+          className:  exception.class.to_s,
+          message:    exception.message.to_s.encode('UTF-16', :undef => :replace, :invalid => :replace).encode('UTF-8'),
+          stackTrace: (exception.backtrace || []).map { |line| stack_trace_for(line) },
+        }
+
+        details.update(innerError: error_details(exception.cause)) if exception.respond_to?(:cause) && exception.cause
+
+        details
+      end
+
+      def stack_trace_for(line)
+        # see http://www.ruby-doc.org/core-2.0/Exception.html#method-i-backtrace
+        file_name, line_number, method = line.split(":")
+        {
+          lineNumber: line_number,
+          fileName:   file_name,
+          methodName: method ? method.gsub(/^in `(.*?)'$/, "\\1") : "(none)"
+        }
+      end
+
+      def hostname
+        Socket.gethostname
+      end
+
+      def version
+        Raygun.configuration.version
+      end
+
+      def user_information(env)
+        env["raygun.affected_user"]
+      end
+
+      def affected_user_present?(env)
+        !!env["raygun.affected_user"]
+      end
+
+      def rack_env
+        ENV["RACK_ENV"]
+      end
+
+      def rails_env
+        ENV["RAILS_ENV"]
+      end
+
+      def request_information(env)
+        Raygun.log('retrieving request information')
+
+        return {} if env.nil? || env.empty?
+        {
+          hostName:    env["SERVER_NAME"],
+          url:         env["PATH_INFO"],
+          httpMethod:  env["REQUEST_METHOD"],
+          iPAddress:   "#{ip_address_from(env)}",
+          queryString: Rack::Utils.parse_nested_query(env["QUERY_STRING"]),
+          headers:     headers(env),
+          form:        form_params(env),
+          rawData:     raw_data(env)
+        }
+      end
+
+      def headers(rack_env)
+        rack_env.select { |k, v| k.to_s.start_with?("HTTP_") }.inject({}) do |hsh, (k, v)|
+          hsh[normalize_raygun_header_key(k)] = v
+          hsh
+        end
+      end
+
+      def normalize_raygun_header_key(key)
+        key.sub(/^HTTP_/, '')
+           .sub(/_/, ' ')
+           .split.map(&:capitalize).join(' ')
+           .sub(/ /, '-')
+      end
+
+      def form_params(env)
+        Raygun.log('retrieving form params')
+
+        params = action_dispatch_params(env) || rack_params(env) || {}
+        filter_params_with_blacklist(params, env["action_dispatch.parameter_filter"])
+      end
+
+      def action_dispatch_params(env)
+        env["action_dispatch.request.parameters"]
+      end
+
+      def rack_params(env)
+        request = Rack::Request.new(env)
+        request.params if env["rack.input"]
+      end
+
+      def raw_data(rack_env)
+        Raygun.log('retrieving raw data')
+        request = Rack::Request.new(rack_env)
+
+        return unless Raygun.configuration.record_raw_data
+        return if request.get?
+        Raygun.log('passed raw_data checks')
+
+        input = rack_env['rack.input']
+
+        if input && !request.form_data?
+          input.rewind
+
+          body = input.read(4096) || ''
+          input.rewind
+
+          body
+        else
+          {}
+        end
+      end
+
+      def filter_custom_data(env)
+        params = env.delete(:custom_data) || {}
+        filter_params_with_blacklist(params, env["action_dispatch.parameter_filter"])
+      end
+
+      # see https://raygun.com/documentation/product-guides/crash-reporting/api/
+      def build_payload_hash(exception_instance, env = {}, user = nil)
+        Raygun.log('building payload hash')
+        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
+          tags << rails_env
+        else
+          tags << rack_env
+        end
+
+        configuration_tags = []
+        if Raygun.configuration.tags.is_a?(Proc)
+          configuration_tags = Raygun.configuration.tags.call(exception_instance, env)
+        else
+          configuration_tags = Raygun.configuration.tags
+        end
+
+        Raygun.log('set tags')
+
+        grouping_key = env.delete(:grouping_key)
+        correlation_id = env.delete(:correlation_id)
+
+        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
+
+        Raygun.log('set custom data')
+
+        error_details = {
+            machineName:    hostname,
+            version:        version,
+            client:         client_details,
+            error:          error_details(exception_instance),
+            userCustomData: exception_custom_data.merge(custom_data).merge(configured_custom_data),
+            tags:           configuration_tags.concat(tags).compact.uniq,
+            request:        request_information(env),
+            environment:    {
+              utcOffset: Time.now.utc_offset / 3600
+            }
+        }
+        store = ::Raygun::Breadcrumbs::Store
+        error_details[:breadcrumbs] = store.take_until_size(MAX_BREADCRUMBS_SIZE).map(&:build_payload) if store.any?
+
+        Raygun.log('set details and breadcrumbs')
+
+        error_details.merge!(groupingKey: grouping_key) if grouping_key
+        error_details.merge!(correlationId: correlation_id) if correlation_id
+
+        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
+
+        Raygun.log('set user details')
+
+        if Raygun.configuration.filter_payload_with_whitelist
+          Raygun.log('filtering payload with whitelist')
+          error_details = filter_payload_with_whitelist(error_details)
+        end
+
+        {
+          occurredOn: Time.now.utc.iso8601,
+          details:    error_details
+        }
+      end
+
+      def create_entry(payload_hash)
+        Raygun.log('sending payload to api')
+
+        self.class.post(
+          "/entries",
+          verify_peer: true,
+          verify: true,
+          headers: @headers,
+          body: JSON.generate(payload_hash),
+        )
+      end
+
+      def filter_params_with_blacklist(params_hash = {}, extra_filter_keys = nil)
+        filter_parameters = Raygun.configuration.filter_parameters
+
+        if filter_parameters.is_a? Proc
+          filter_parameters.call(params_hash)
+        else
+          filter_keys = (Array(extra_filter_keys) + filter_parameters).map(&:to_s)
+
+          filter_params_with_array(params_hash, filter_keys)
+        end
+      end
+
+      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)
+        # Recursive filtering of (nested) hashes
+        (params_hash || {}).inject({}) do |result, (k, v)|
+          result[k] = case v
+          when Hash
+            filter_params_with_array(v, filter_keys)
+          else
+            filter_keys.any? { |fk| /#{fk}/i === k.to_s } ? "[FILTERED]" : v
+          end
+          result
+        end
+      end
+
+      def ip_address_from(env_hash)
+        ENV_IP_ADDRESS_KEYS.each do |key_to_try|
+          return env_hash[key_to_try] unless env_hash[key_to_try].nil? || env_hash[key_to_try] == ""
+        end
+        "(Not Available)"
+      end
+
+      def print_api_key_warning
+        $stderr.puts(NO_API_KEY_MESSAGE)
+      end
+  end
+end