bugsnag 4.2.1 → 6.27.1

data/lib/bugsnag/middleware/rack_request.rb

@@ -1,24 +1,37 @@
 module Bugsnag::Middleware
+  ##
+  # Extracts and attaches rack data to an error report
   class RackRequest
+    SPOOF = "[SPOOF]".freeze
+    COOKIE_HEADER = "Cookie".freeze
+
     def initialize(bugsnag)
       @bugsnag = bugsnag
     end
 
-    def call(notification)
-      if notification.request_data[:rack_env]
-        env = notification.request_data[:rack_env]
+    def call(report)
+      if report.request_data[:rack_env]
+        env = report.request_data[:rack_env]
 
         request = ::Rack::Request.new(env)
 
-        params = request.params rescue {}
+        params =
+          # if the request body isn't rewindable then we can't read request.POST
+          # which is used internally by request.params
+          if request.body.respond_to?(:rewind)
+            request.params rescue {}
+          else
+            request.GET rescue {}
+          end
 
+        client_ip = request.ip.to_s rescue SPOOF
         session = env["rack.session"]
 
-        # Set the context
-        notification.context = "#{request.request_method} #{request.path}"
+        # Set the automatic context
+        report.automatic_context = "#{request.request_method} #{request.path}"
 
         # Set a sensible default for user_id
-        notification.user_id = request.ip
+        report.user["id"] = request.ip
 
         # Build the clean url (hide the port if it is obvious)
         url = "#{request.scheme}://#{request.host}"
@@ -26,53 +39,136 @@ module Bugsnag::Middleware
 
         # If app is passed a bad URL, this code will crash attempting to clean it
         begin
-          url << Bugsnag::Cleaner.new(notification.configuration.params_filters).clean_url(request.fullpath)
+          url << Bugsnag.cleaner.clean_url(request.fullpath)
         rescue StandardError => stde
-          Bugsnag.log "RackRequest - Rescued error while cleaning request.fullpath: #{stde}"
+          Bugsnag.configuration.warn "RackRequest - Rescued error while cleaning request.fullpath: #{stde}"
         end
 
-        headers = {}
-
-        env.each_pair do |key, value|
-          if key.to_s.start_with?("HTTP_")
-            header_key = key[5..-1]
-          elsif ["CONTENT_TYPE", "CONTENT_LENGTH"].include?(key)
-            header_key = key
-          else
-            next
-          end
-
-          headers[header_key.split("_").map {|s| s.capitalize}.join("-")] = value
+        referer = nil
+        begin
+          referer = Bugsnag.cleaner.clean_url(request.referer) if request.referer
+        rescue StandardError => stde
+          Bugsnag.configuration.warn "RackRequest - Rescued error while cleaning request.referer: #{stde}"
         end
 
         # Add a request tab
-        notification.add_tab(:request, {
+        report.add_tab(:request, {
           :url => url,
           :httpMethod => request.request_method,
           :params => params.to_hash,
-          :referer => request.referer,
-          :clientIp => request.ip,
-          :headers => headers
+          :referer => referer,
+          :clientIp => client_ip,
+          :headers => format_headers(env, referer)
         })
 
+        # add the HTTP version if present
+        if env["SERVER_PROTOCOL"]
+          report.add_metadata(:request, :httpVersion, env["SERVER_PROTOCOL"])
+        end
+
+        add_request_body(report, request, env)
+        add_cookies(report, request)
+
         # Add an environment tab
-        if notification.configuration.send_environment
-          notification.add_tab(:environment, env)
+        if report.configuration.send_environment
+          report.add_tab(:environment, env)
         end
 
         # Add a session tab
         if session
           if session.is_a?(Hash)
             # Rails 3
-            notification.add_tab(:session, session)
+            report.add_tab(:session, session)
           elsif session.respond_to?(:to_hash)
             # Rails 4
-            notification.add_tab(:session, session.to_hash)
+            report.add_tab(:session, session.to_hash)
           end
         end
       end
 
-      @bugsnag.call(notification)
+      @bugsnag.call(report)
+    end
+
+    private
+
+    def format_headers(env, referer)
+      headers = {}
+
+      env.each_pair do |key, value|
+        if key.to_s.start_with?("HTTP_")
+          header_key = key[5..-1]
+        elsif ["CONTENT_TYPE", "CONTENT_LENGTH"].include?(key)
+          header_key = key
+        else
+          next
+        end
+
+        headers[header_key.split("_").map {|s| s.capitalize}.join("-")] = value
+      end
+
+      headers["Referer"] = referer if headers["Referer"]
+
+      headers
+    end
+
+    def add_request_body(report, request, env)
+      begin
+        body = parsed_request_body(request, env)
+      rescue StandardError
+        return nil
+      end
+
+      # this request may not have a body
+      return unless body.is_a?(Hash) && !body.empty?
+
+      report.add_metadata(:request, :body, body)
+    end
+
+    def parsed_request_body(request, env)
+      # if the request is not rewindable then either:
+      # - it's been read already and so is impossible to read
+      # - it hasn't been read yet and us reading it will prevent the user from
+      #   reading it themselves
+      # in either case we should avoid attempting to
+      return nil unless request.body.respond_to?(:rewind)
+
+      if request.form_data?
+        begin
+          return request.POST
+        ensure
+          request.body.rewind
+        end
+      end
+
+      content_type = env["CONTENT_TYPE"]
+
+      return nil if content_type.nil?
+      return nil unless content_type.include?('/json') || content_type.include?('+json')
+
+      begin
+        body = request.body
+
+        JSON.parse(body.read)
+      ensure
+        # the body must be rewound so other things can read it after we do
+        body.rewind
+      end
+    end
+
+    def add_cookies(report, request)
+      return unless record_cookies?
+
+      cookies = request.cookies rescue nil
+
+      return unless cookies.is_a?(Hash) && !cookies.empty?
+
+      report.add_metadata(:request, :cookies, cookies)
+    end
+
+    def record_cookies?
+      # only record cookies in the request if none of the filters match "Cookie"
+      # the "Cookie" header will be filtered as normal
+      !Bugsnag.cleaner.filters_match?(COOKIE_HEADER)
     end
   end
 end

data/lib/bugsnag/middleware/rails3_request.rb

@@ -1,42 +1,40 @@
 module Bugsnag::Middleware
+  ##
+  # Extracts and attaches rails and rack environment data to an error report
   class Rails3Request
+    SPOOF = "[SPOOF]".freeze
+
     def initialize(bugsnag)
       @bugsnag = bugsnag
     end
 
-    def call(notification)
-      if notification.request_data[:rack_env]
-        env = notification.request_data[:rack_env]
+    def call(report)
+      if report.request_data[:rack_env]
+        env = report.request_data[:rack_env]
         params = env["action_dispatch.request.parameters"]
+        client_ip = env["action_dispatch.remote_ip"].to_s rescue SPOOF
 
         if params
-          # Set the context
-          notification.context = "#{params[:controller]}##{params[:action]}"
+          # Set the automatic context
+          report.automatic_context = "#{params[:controller]}##{params[:action]}"
 
           # Augment the request tab
-          notification.add_tab(:request, {
+          report.add_tab(:request, {
             :railsAction => "#{params[:controller]}##{params[:action]}",
             :params => params
           })
         end
 
         # Use action_dispatch.remote_ip for IP address fields and send request id
-        notification.add_tab(:request, {
-          :clientIp => env["action_dispatch.remote_ip"],
+        report.add_tab(:request, {
+          :clientIp => client_ip,
           :requestId => env["action_dispatch.request_id"]
         })
 
-        notification.user_id = env["action_dispatch.remote_ip"]
-
-        # Add the rails version
-        if notification.configuration.send_environment
-          notification.add_tab(:environment, {
-            :railsVersion => Rails::VERSION::STRING
-          })
-        end
+        report.user["id"] = client_ip
       end
 
-      @bugsnag.call(notification)
+      @bugsnag.call(report)
     end
   end
 end

data/lib/bugsnag/middleware/rake.rb

@@ -1,23 +1,25 @@
 module Bugsnag::Middleware
+  ##
+  # Extracts and attaches rake task information to an error report
   class Rake
     def initialize(bugsnag)
       @bugsnag = bugsnag
     end
 
-    def call(notification)
-      task = notification.request_data[:bugsnag_running_task]
+    def call(report)
+      task = report.request_data[:bugsnag_running_task]
 
       if task
-        notification.add_tab(:rake_task, {
+        report.add_tab(:rake_task, {
           :name => task.name,
           :description => task.full_comment,
           :arguments => task.arg_description
         })
 
-        notification.context ||= task.name
+        report.automatic_context ||= task.name
       end
 
-      @bugsnag.call(notification)
+      @bugsnag.call(report)
     end
   end
 end

data/lib/bugsnag/middleware/session_data.rb

@@ -0,0 +1,25 @@
+module Bugsnag::Middleware
+  ##
+  # Attaches information about current session to an error report
+  class SessionData
+    def initialize(bugsnag)
+      @bugsnag = bugsnag
+    end
+
+    def call(report)
+      session = Bugsnag::SessionTracker.get_current_session
+
+      if session && !session[:paused?]
+        if report.unhandled
+          session[:events][:unhandled] += 1
+        else
+          session[:events][:handled] += 1
+        end
+
+        report.session = session
+      end
+
+      @bugsnag.call(report)
+    end
+  end
+end

data/lib/bugsnag/middleware/sidekiq.rb

@@ -1,13 +1,18 @@
 module Bugsnag::Middleware
+  ##
+  # Attaches Sidekiq job information to an error report
   class Sidekiq
     def initialize(bugsnag)
       @bugsnag = bugsnag
     end
 
-    def call(notification)
-      sidekiq = notification.request_data[:sidekiq]
-      notification.add_tab(:sidekiq, sidekiq) if sidekiq
-      @bugsnag.call(notification)
+    def call(report)
+      sidekiq = report.request_data[:sidekiq]
+      if sidekiq
+        report.add_tab(:sidekiq, sidekiq)
+        report.automatic_context ||= "#{sidekiq[:msg]['wrapped'] || sidekiq[:msg]['class']}@#{sidekiq[:msg]['queue']}"
+      end
+      @bugsnag.call(report)
     end
   end
 end

data/lib/bugsnag/middleware/suggestion_data.rb

@@ -0,0 +1,34 @@
+module Bugsnag::Middleware
+  ##
+  # Attaches any "Did you mean?" suggestions to the report
+  class SuggestionData
+
+    CAPTURE_REGEX = /Did you mean\?([\s\S]+)$/
+    DELIMITER = "\n"
+
+    def initialize(bugsnag)
+      @bugsnag = bugsnag
+    end
+
+    def call(event)
+      matches = []
+
+      event.errors.each do |error|
+        match = CAPTURE_REGEX.match(error.error_message)
+
+        next unless match
+
+        suggestions = match.captures[0].split(DELIMITER)
+        matches.concat(suggestions.map(&:strip))
+      end
+
+      if matches.size == 1
+        event.add_metadata(:error, { suggestion: matches.first })
+      elsif matches.size > 1
+        event.add_metadata(:error, { suggestions: matches })
+      end
+
+      @bugsnag.call(event)
+    end
+  end
+end

data/lib/bugsnag/middleware/warden_user.rb

@@ -1,4 +1,6 @@
 module Bugsnag::Middleware
+  ##
+  # Extracts and attaches user information from Warden to an error report
   class WardenUser
     SCOPE_PATTERN = /^warden\.user\.([^.]+)\.key$/
     COMMON_USER_FIELDS = [:email, :name, :first_name, :last_name, :created_at, :id]
@@ -7,9 +9,9 @@ module Bugsnag::Middleware
       @bugsnag = bugsnag
     end
 
-    def call(notification)
-      if notification.request_data[:rack_env] && notification.request_data[:rack_env]["warden"]
-        env = notification.request_data[:rack_env]
+    def call(report)
+      if report.request_data[:rack_env] && report.request_data[:rack_env]["warden"]
+        env = report.request_data[:rack_env]
         session = env["rack.session"] || {}
 
         # Find all warden user scopes
@@ -21,7 +23,10 @@ module Bugsnag::Middleware
           # Extract useful user information
           user = {}
           user_object = env["warden"].user({:scope => best_scope, :run_callbacks => false}) rescue nil
+
           if user_object
+            user[:warden_scope] = best_scope
+
             # Build the user info for this scope
             COMMON_USER_FIELDS.each do |field|
               user[field] = user_object.send(field) if user_object.respond_to?(field)
@@ -29,11 +34,11 @@ module Bugsnag::Middleware
           end
 
           # We merge the first warden scope down, so that it is the main "user" for the request
-          notification.user = user unless user.empty?
+          report.user = user unless user.empty?
         end
       end
 
-      @bugsnag.call(notification)
+      @bugsnag.call(report)
     end
   end
-end
+end

data/lib/bugsnag/middleware_stack.rb

@@ -1,11 +1,19 @@
+require "bugsnag/on_error_callbacks"
+
 module Bugsnag
   class MiddlewareStack
+    ##
+    # Creates the middleware stack.
     def initialize
       @middlewares = []
       @disabled_middleware = []
       @mutex = Mutex.new
     end
 
+    ##
+    # Defines a new middleware to use in the middleware call sequence.
+    #
+    # Will return early if given middleware is disabled or already included.
     def use(new_middleware)
       @mutex.synchronize do
         return if @disabled_middleware.include?(new_middleware)
@@ -15,6 +23,11 @@ module Bugsnag
       end
     end
 
+    ##
+    # Inserts a new middleware to use after a given middleware already added.
+    #
+    # Will return early if given middleware is disabled or already added.
+    # New middleware will be inserted last if the existing middleware is not already included.
     def insert_after(after, new_middleware)
       @mutex.synchronize do
         return if @disabled_middleware.include?(new_middleware)
@@ -34,6 +47,11 @@ module Bugsnag
       end
     end
 
+    ##
+    # Inserts a new middleware to use before a given middleware already added.
+    #
+    # Will return early if given middleware is disabled or already added.
+    # New middleware will be inserted last if the existing middleware is not already included.
     def insert_before(before, new_middleware)
       @mutex.synchronize do
         return if @disabled_middleware.include?(new_middleware)
@@ -49,21 +67,38 @@ module Bugsnag
       end
     end
 
+    ##
+    # Disable the given middleware. This removes them from the list of
+    # middleware and ensures they cannot be added again
+    #
+    # See also {#remove}
     def disable(*middlewares)
       @mutex.synchronize do
         @disabled_middleware += middlewares
 
-        @middlewares.delete_if {|m| @disabled_middleware.include?(m)}
+        @middlewares.delete_if {|m| @disabled_middleware.include?(m) }
+      end
+    end
+
+    ##
+    # Remove the given middleware from the list of middleware
+    #
+    # This is like {#disable} but allows the middleware to be added again
+    def remove(*middlewares)
+      @mutex.synchronize do
+        @middlewares.delete_if {|m| middlewares.include?(m) }
       end
     end
 
-    # This allows people to proxy methods to the array if they want to do more complex stuff
+    ##
+    # Allows the user to proxy methods for more complex functionality.
     def method_missing(method, *args, &block)
       @middlewares.send(method, *args, &block)
     end
 
-    # Runs the middleware stack and calls
-    def run(notification)
+    ##
+    # Runs the middleware stack.
+    def run(report)
       # The final lambda is the termination of the middleware stack. It calls deliver on the notification
       lambda_has_run = false
       notify_lambda = lambda do |notif|
@@ -73,26 +108,44 @@ module Bugsnag
 
       begin
         # We reverse them, so we can call "call" on the first middleware
-        middleware_procs.reverse.inject(notify_lambda) { |n,e| e.call(n) }.call(notification)
+        middleware_procs.reverse.inject(notify_lambda) {|n, e| e.call(n) }.call(report)
       rescue StandardError => e
         # KLUDGE: Since we don't re-raise middleware exceptions, this breaks rspec
         raise if e.class.to_s == "RSpec::Expectations::ExpectationNotMetError"
 
         # We dont notify, as we dont want to loop forever in the case of really broken middleware, we will
         # still send this notify
-        Bugsnag.warn "Bugsnag middleware error: #{e}"
-        Bugsnag.log "Middleware error stacktrace: #{e.backtrace.inspect}"
+        Bugsnag.configuration.warn "Bugsnag middleware error: #{e}"
+        Bugsnag.configuration.warn "Middleware error stacktrace: #{e.backtrace.inspect}"
       end
 
       # Ensure that the deliver has been performed, and no middleware has botched it
-      notify_lambda.call(notification) unless lambda_has_run
+      notify_lambda.call(report) unless lambda_has_run
     end
 
     private
+
+    ##
     # Generates a list of middleware procs that are ready to be run
     # Pass each one a reference to the next in the queue
+    #
+    # @return [Array<Proc>]
     def middleware_procs
-      @middlewares.map{|middleware| proc { |next_middleware| middleware.new(next_middleware) } }
+      # Split the middleware into separate lists of callables (e.g. Proc, Lambda, Method) and Classes
+      callables, classes = @middlewares.partition {|middleware| middleware.respond_to?(:call) }
+
+      # Wrap the classes in a proc that, when called, news up the middleware and
+      # passes the next middleware in the queue
+      middleware_instances = classes.map do |middleware|
+        proc {|next_middleware| middleware.new(next_middleware) }
+      end
+
+      # Wrap the list of callables in a proc that, when called, wraps them in an
+      # 'OnErrorCallbacks' instance that also has a reference to the next middleware
+      wrapped_callables = proc {|next_middleware| OnErrorCallbacks.new(next_middleware, callables) }
+
+      # Return the combined middleware and wrapped callables
+      middleware_instances.push(wrapped_callables)
     end
   end
 end

data/lib/bugsnag/on_error_callbacks.rb

@@ -0,0 +1,33 @@
+module Bugsnag
+  # @api private
+  class OnErrorCallbacks
+    def initialize(next_middleware, callbacks)
+      @next_middleware = next_middleware
+      @callbacks = callbacks
+    end
+
+    ##
+    # @param report [Report]
+    def call(report)
+      @callbacks.each do |callback|
+        begin
+          should_continue = callback.call(report)
+        rescue StandardError => e
+          Bugsnag.configuration.warn("Error occurred in on_error callback: '#{e}'")
+          Bugsnag.configuration.warn("on_error callback stacktrace: #{e.backtrace.inspect}")
+        end
+
+        # If a callback returns false, we ignore the report and stop running callbacks
+        # Note that we explicitly check for 'false' so that callbacks don't need
+        # to return anything (i.e. can return 'nil') and we still continue
+        next unless should_continue == false
+
+        report.ignore!
+
+        break
+      end
+
+      @next_middleware.call(report)
+    end
+  end
+end