bugsnag 6.12.2 → 6.16.0

data/lib/bugsnag/integrations/rake.rb

@@ -11,7 +11,8 @@ if Gem::Version.new(RUBY_VERSION.dup) >= Gem::Version.new('2.0')
 
       # Executes the rake task with Bugsnag setup with contextual data.
       def execute(args = nil)
-        Bugsnag.configuration.app_type ||= "rake"
+        Bugsnag.configuration.detected_app_type = "rake"
+
         old_task = Bugsnag.configuration.request_data[:bugsnag_running_task]
         Bugsnag.configuration.set_request_data :bugsnag_running_task, self
         Bugsnag.configuration.runtime_versions["rake"] = ::Rake::VERSION
@@ -42,7 +43,8 @@ else
     ##
     # Executes the rake task with Bugsnag setup with contextual data.
     def execute_with_bugsnag(args=nil)
-      Bugsnag.configuration.app_type ||= "rake"
+      Bugsnag.configuration.detected_app_type = "rake"
+
       old_task = Bugsnag.configuration.request_data[:bugsnag_running_task]
       Bugsnag.configuration.set_request_data :bugsnag_running_task, self
       Bugsnag.configuration.runtime_versions["rake"] = ::Rake::VERSION

data/lib/bugsnag/integrations/resque.rb

@@ -60,13 +60,13 @@ Bugsnag::Resque.add_failure_backend
 
 if Resque::Worker.new(:bugsnag_fork_check).fork_per_job?
   Resque.after_fork do
-    Bugsnag.configuration.app_type = "resque"
+    Bugsnag.configuration.detected_app_type = "resque"
     Bugsnag.configuration.default_delivery_method = :synchronous
     Bugsnag.configuration.runtime_versions["resque"] = ::Resque::VERSION
   end
 else
   Resque.before_first_fork do
-    Bugsnag.configuration.app_type = "resque"
+    Bugsnag.configuration.detected_app_type = "resque"
     Bugsnag.configuration.default_delivery_method = :synchronous
     Bugsnag.configuration.runtime_versions["resque"] = ::Resque::VERSION
   end

data/lib/bugsnag/integrations/shoryuken.rb

@@ -11,8 +11,9 @@ module Bugsnag
 
     def initialize
       Bugsnag.configure do |config|
-        config.app_type ||= "shoryuken"
+        config.detected_app_type = "shoryuken"
         config.default_delivery_method = :synchronous
+        config.runtime_versions["shoryuken"] = ::Shoryuken::VERSION
       end
     end
 

data/lib/bugsnag/integrations/sidekiq.rb

@@ -13,7 +13,7 @@ module Bugsnag
 
     def initialize
       Bugsnag.configuration.internal_middleware.use(Bugsnag::Middleware::Sidekiq)
-      Bugsnag.configuration.app_type = "sidekiq"
+      Bugsnag.configuration.detected_app_type = "sidekiq"
       Bugsnag.configuration.default_delivery_method = :synchronous
       Bugsnag.configuration.runtime_versions["sidekiq"] = ::Sidekiq::VERSION
     end

data/lib/bugsnag/middleware/delayed_job.rb

@@ -24,6 +24,7 @@ module Bugsnag::Middleware
           job_data[:active_job] = job.payload_object.job_data if job.payload_object.respond_to?(:job_data)
           payload_data = construct_job_payload(job.payload_object)
           report.context = payload_data[:display_name] if payload_data.include?(:display_name)
+          report.context ||= payload_data[:class] if payload_data.include?(:class)
           job_data[:payload] = payload_data
         end
 

data/lib/bugsnag/middleware/discard_error_class.rb

@@ -0,0 +1,30 @@
+module Bugsnag::Middleware
+  ##
+  # Determines if the exception should be ignored based on the configured
+  # `discard_classes`
+  class DiscardErrorClass
+    ##
+    # @param middleware [#call] The next middleware to call
+    def initialize(middleware)
+      @middleware = middleware
+    end
+
+    ##
+    # @param report [Report]
+    def call(report)
+      should_discard = report.raw_exceptions.any? do |ex|
+        report.configuration.discard_classes.any? do |to_ignore|
+          case to_ignore
+          when String then to_ignore == ex.class.name
+          when Regexp then to_ignore =~ ex.class.name
+          else false
+          end
+        end
+      end
+
+      report.ignore! if should_discard
+
+      @middleware.call(report)
+    end
+  end
+end

data/lib/bugsnag/middleware/exception_meta_data.rb

@@ -9,21 +9,27 @@ module Bugsnag::Middleware
     def call(report)
       # Apply the user's information attached to the exceptions
       report.raw_exceptions.each do |exception|
-        if exception.respond_to?(:bugsnag_user_id) && exception.bugsnag_user_id.is_a?(String)
-          report.user = {id: exception.bugsnag_user_id}
+        if exception.respond_to?(:bugsnag_user_id)
+          user_id = exception.bugsnag_user_id
+          report.user = {id: user_id} if user_id.is_a?(String)
         end
 
-        if exception.respond_to?(:bugsnag_context) && exception.bugsnag_context.is_a?(String)
-          report.context = exception.bugsnag_context
+        if exception.respond_to?(:bugsnag_context)
+          context = exception.bugsnag_context
+          report.context = context if context.is_a?(String)
         end
 
-        if exception.respond_to?(:bugsnag_grouping_hash) && exception.bugsnag_grouping_hash.is_a?(String)
-          report.grouping_hash = exception.bugsnag_grouping_hash
+        if exception.respond_to?(:bugsnag_grouping_hash)
+          group_hash = exception.bugsnag_grouping_hash
+          report.grouping_hash = group_hash if group_hash.is_a?(String)
         end
 
-        if exception.respond_to?(:bugsnag_meta_data) && exception.bugsnag_meta_data.is_a?(Hash)
-          exception.bugsnag_meta_data.each do |key, value|
-            report.add_tab key, value
+        if exception.respond_to?(:bugsnag_meta_data)
+          meta_data = exception.bugsnag_meta_data
+          if meta_data.is_a?(Hash)
+            meta_data.each do |key, value|
+              report.add_tab key, value
+            end
           end
         end
       end

data/lib/bugsnag/middleware/ignore_error_class.rb

@@ -2,6 +2,8 @@ module Bugsnag::Middleware
   ##
   # Determines if the exception should be ignored based on the configured
   # `ignore_classes`
+  #
+  # @deprecated Use {DiscardErrorClass} instead
   class IgnoreErrorClass
     def initialize(bugsnag)
       @bugsnag = bugsnag

data/lib/bugsnag/middleware/rack_request.rb

@@ -28,18 +28,16 @@ module Bugsnag::Middleware
         url = "#{request.scheme}://#{request.host}"
         url << ":#{request.port}" unless [80, 443].include?(request.port)
 
-        cleaner = Bugsnag::Cleaner.new(report.configuration.meta_data_filters)
-
         # If app is passed a bad URL, this code will crash attempting to clean it
         begin
-          url << cleaner.clean_url(request.fullpath)
+          url << Bugsnag.cleaner.clean_url(request.fullpath)
         rescue StandardError => stde
           Bugsnag.configuration.warn "RackRequest - Rescued error while cleaning request.fullpath: #{stde}"
         end
 
         referer = nil
         begin
-          referer = cleaner.clean_url(request.referer) if request.referer
+          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

data/lib/bugsnag/middleware_stack.rb

@@ -1,3 +1,5 @@
+require "bugsnag/on_error_callbacks"
+
 module Bugsnag
   class MiddlewareStack
     ##
@@ -65,11 +67,26 @@ 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
 
@@ -91,7 +108,7 @@ 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(report)
+        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"
@@ -107,10 +124,28 @@ module Bugsnag
     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 Procs and Classes
+      procs, classes = @middlewares.partition {|middleware| middleware.is_a?(Proc) }
+
+      # 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 procs in a proc that, when called, wraps them in an
+      # 'OnErrorCallbacks' instance that also has a reference to the next middleware
+      wrapped_procs = proc {|next_middleware| OnErrorCallbacks.new(next_middleware, procs) }
+
+      # Return the combined middleware and wrapped procs
+      middleware_instances.push(wrapped_procs)
     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

data/lib/bugsnag/report.rb

@@ -97,6 +97,7 @@ module Bugsnag
           releaseStage: release_stage,
           type: app_type
         },
+        breadcrumbs: breadcrumbs.map(&:to_h),
         context: context,
         device: {
           hostname: hostname,
@@ -104,6 +105,7 @@ module Bugsnag
         },
         exceptions: exceptions,
         groupingHash: grouping_hash,
+        metaData: meta_data,
         session: session,
         severity: severity,
         severityReason: severity_reason,
@@ -111,19 +113,7 @@ module Bugsnag
         user: user
       }
 
-      # cleanup character encodings
-      payload_event = Bugsnag::Cleaner.clean_object_encoding(payload_event)
-
-      # filter out sensitive values in (and cleanup encodings) metaData
-      filter_cleaner = Bugsnag::Cleaner.new(configuration.meta_data_filters)
-      payload_event[:metaData] = filter_cleaner.clean_object(meta_data)
-      payload_event[:breadcrumbs] = breadcrumbs.map do |breadcrumb|
-        breadcrumb_hash = breadcrumb.to_h
-        breadcrumb_hash[:metaData] = filter_cleaner.clean_object(breadcrumb_hash[:metaData])
-        breadcrumb_hash
-      end
-
-      payload_event.reject! {|k,v| v.nil? }
+      payload_event.reject! {|k, v| v.nil? }
 
       # return the payload hash
       {
@@ -192,7 +182,7 @@ module Bugsnag
         {
           errorClass: error_class(exception),
           message: exception.message,
-          stacktrace: Stacktrace.new(exception.backtrace, configuration).to_a
+          stacktrace: Stacktrace.process(exception.backtrace, configuration)
         }
       end
     end

data/lib/bugsnag/session_tracker.rb

@@ -1,11 +1,9 @@
 require 'thread'
 require 'time'
 require 'securerandom'
-require 'concurrent'
 
 module Bugsnag
   class SessionTracker
-
     THREAD_SESSION = "bugsnag_session"
     SESSION_PAYLOAD_VERSION = "1.0"
     MUTEX = Mutex.new
@@ -27,6 +25,8 @@ module Bugsnag
     ##
     # Initializes the session tracker.
     def initialize
+      require 'concurrent'
+
       @session_counts = Concurrent::Hash.new(0)
     end
 
@@ -139,4 +139,4 @@ module Bugsnag
       Bugsnag::Delivery[Bugsnag.configuration.delivery_method].deliver(Bugsnag.configuration.session_endpoint, payload, Bugsnag.configuration, options)
     end
   end
-end
+end

data/lib/bugsnag/stacktrace.rb

@@ -1,55 +1,51 @@
-module Bugsnag
-  class Stacktrace
+require_relative 'code_extractor'
 
+module Bugsnag
+  module Stacktrace
     # e.g. "org/jruby/RubyKernel.java:1264:in `catch'"
     BACKTRACE_LINE_REGEX = /^((?:[a-zA-Z]:)?[^:]+):(\d+)(?::in `([^']+)')?$/
 
     # e.g. "org.jruby.Ruby.runScript(Ruby.java:807)"
     JAVA_BACKTRACE_REGEX = /^(.*)\((.*)(?::([0-9]+))?\)$/
 
-    # Path to vendored code. Used to mark file paths as out of project.
-    VENDOR_PATH = /^(vendor\/|\.bundle\/)/
-
     ##
     # Process a backtrace and the configuration into a parsed stacktrace.
-    def initialize(backtrace, configuration)
-      @configuration = configuration
+    #
+    # @param backtrace [Array, nil] If nil, 'caller' will be used instead
+    # @param configuration [Configuration]
+    # @return [Array]
+    def self.process(backtrace, configuration)
+      code_extractor = CodeExtractor.new(configuration)
 
       backtrace = caller if !backtrace || backtrace.empty?
 
-      @processed_backtrace = backtrace.map do |trace|
+      processed_backtrace = backtrace.map do |trace|
+        # Parse the stacktrace line
         if trace.match(BACKTRACE_LINE_REGEX)
           file, line_str, method = [$1, $2, $3]
         elsif trace.match(JAVA_BACKTRACE_REGEX)
           method, file, line_str = [$1, $2, $3]
         end
 
-        # Parse the stacktrace line
-
-        next(nil) if file.nil?
+        next if file.nil?
 
         # Expand relative paths
-        p = Pathname.new(file)
-        if p.relative?
-          file = p.realpath.to_s rescue file
-        end
+        file = File.realpath(file) rescue file
 
         # Generate the stacktrace line hash
-        trace_hash = {}
-        trace_hash[:lineNumber] = line_str.to_i
+        trace_hash = { lineNumber: line_str.to_i }
 
-        if configuration.send_code
-          trace_hash[:code] = code(file, trace_hash[:lineNumber])
-        end
+        # Save a copy of the file path as we're about to modify it but need the
+        # raw version when extracting code (otherwise we can't open the file)
+        raw_file_path = file.dup
 
         # Clean up the file path in the stacktrace
-        if defined?(@configuration.project_root) && @configuration.project_root.to_s != ''
-          trace_hash[:inProject] = true if file.start_with?(@configuration.project_root.to_s)
-          file.sub!(/#{@configuration.project_root}\//, "")
-          trace_hash.delete(:inProject) if file.match(VENDOR_PATH)
+        if defined?(configuration.project_root) && configuration.project_root.to_s != ''
+          trace_hash[:inProject] = true if file.start_with?(configuration.project_root.to_s)
+          file.sub!(/#{configuration.project_root}\//, "")
+          trace_hash.delete(:inProject) if file.match(configuration.vendor_path)
         end
 
-
         # Strip common gem path prefixes
         if defined?(Gem)
           file = Gem.path.inject(file) {|line, path| line.sub(/#{path}\//, "") }
@@ -60,59 +56,16 @@ module Bugsnag
         # Add a method if we have it
         trace_hash[:method] = method if method && (method =~ /^__bind/).nil?
 
-        if trace_hash[:file] && !trace_hash[:file].empty?
-          trace_hash
-        else
-          nil
-        end
-      end.compact
-    end
-
-    ##
-    # Returns the processed backtrace
-    def to_a
-      @processed_backtrace
-    end
-
-    private
-
-    def code(file, line_number, num_lines = 7)
-      code_hash = {}
-
-      from_line = [line_number - num_lines, 1].max
-
-      # don't try and open '(irb)' or '-e'
-      return unless File.exist?(file)
-
-      # Populate code hash with line numbers and code lines
-      File.open(file) do |f|
-        current_line_number = 0
-        f.each_line do |line|
-          current_line_number += 1
+        # If we're going to send code then record the raw file path and the
+        # trace_hash, so we can extract from it later
+        code_extractor.add_file(raw_file_path, trace_hash) if configuration.send_code
 
-          next if current_line_number < from_line
-
-          code_hash[current_line_number] = line[0...200].rstrip
-
-          break if code_hash.length >= ( num_lines * 1.5 ).ceil
-        end
-      end
-
-      while code_hash.length > num_lines
-        last_line = code_hash.keys.max
-        first_line = code_hash.keys.min
+        trace_hash
+      end.compact
 
-        if (last_line - line_number) > (line_number - first_line)
-          code_hash.delete(last_line)
-        else
-          code_hash.delete(first_line)
-        end
-      end
+      code_extractor.extract! if configuration.send_code
 
-      code_hash
-    rescue
-      @configuration.warn("Error fetching code: #{$!.inspect}")
-      nil
+      processed_backtrace
     end
   end
 end