bugsnag 6.12.1 → 6.15.0

data/features/steps/ruby_notifier_steps.rb

@@ -1,31 +1,75 @@
-When("I set environment variable {string} to the current IP") do |env_var|
+Then(/^the "(.+)" of the top non-bugsnag stackframe equals (\d+|".+")$/) do |element, value|
+  stacktrace = read_key_path(Server.current_request[:body], 'events.0.exceptions.0.stacktrace')
+  frame_index = stacktrace.find_index { |frame| ! /.*lib\/bugsnag.*\.rb/.match(frame["file"]) }
   steps %Q{
-    When I set environment variable "#{env_var}" to "#{current_ip}"
+    the "#{element}" of stack frame #{frame_index} equals #{value}
   }
 end
 
-When("I set environment variable {string} to the mock API port") do |env_var|
+Then(/^the total sessionStarted count equals (\d+)$/) do |value|
+  session_counts = read_key_path(Server.current_request[:body], "sessionCounts")
+  total_count = session_counts.inject(0) { |count, session| count += session["sessionsStarted"] }
+  assert_equal(value, total_count)
+end
+
+
+# Due to an ongoing discussion on whether the `payload_version` needs to be present within the headers
+# and body of the payload, this step is a local replacement for the similar step present in the main
+# maze-runner library. Once the discussion is resolved this step should be removed and replaced in scenarios
+# with the main library version.
+Then("the request is valid for the error reporting API version {string} for the {string}") do |payload_version, notifier_name|
   steps %Q{
-    When I set environment variable "#{env_var}" to "#{MOCK_API_PORT}"
+    Then the "Bugsnag-Api-Key" header equals "#{$api_key}"
+    And the payload field "apiKey" equals "#{$api_key}"
+    And the "Bugsnag-Payload-Version" header equals "#{payload_version}"
+    And the "Content-Type" header equals "application/json"
+    And the "Bugsnag-Sent-At" header is a timestamp
+
+    And the payload field "notifier.name" equals "#{notifier_name}"
+    And the payload field "notifier.url" is not null
+    And the payload field "notifier.version" is not null
+    And the payload field "events" is a non-empty array
+
+    And each element in payload field "events" has "severity"
+    And each element in payload field "events" has "severityReason.type"
+    And each element in payload field "events" has "unhandled"
+    And each element in payload field "events" has "exceptions"
   }
 end
 
-When("I set environment variable {string} to the proxy settings with credentials {string}") do |env_var, credentials|
+Given("I start the rails service") do
+  rails_version = ENV["RAILS_VERSION"]
   steps %Q{
-    When I set environment variable "#{env_var}" to "#{credentials}@#{current_ip}:#{MOCK_API_PORT}"
+    When I start the service "rails#{rails_version}"
+    And I wait for the host "rails#{rails_version}" to open port "3000"
   }
 end
 
-Then(/^the "(.+)" of the top non-bugsnag stackframe equals (\d+|".+")(?: for request (\d+))?$/) do |element, value, request_index|
-  stacktrace = read_key_path(find_request(request_index)[:body], 'events.0.exceptions.0.stacktrace')
-  frame_index = stacktrace.find_index { |frame| ! /.*lib\/bugsnag.*\.rb/.match(frame["file"]) }
+When("I navigate to the route {string} on the rails app") do |route|
+  rails_version = ENV["RAILS_VERSION"]
   steps %Q{
-    the "#{element}" of stack frame #{frame_index} equals #{value}
+    When I open the URL "http://rails#{rails_version}:3000#{route}"
   }
 end
 
-Then(/^the total sessionStarted count equals (\d+)(?: for request (\d+))?$/) do |value, request_index|
-  session_counts = read_key_path(find_request(request_index)[:body], "sessionCounts")
-  total_count = session_counts.inject(0) { |count, session| count += session["sessionsStarted"] }
-  assert_equal(value, total_count)
-end
+Then("the payload field {string} matches the appropriate Sidekiq handled payload") do |field|
+  if ENV["SIDEKIQ_VERSION"] == "~> 2"
+    created_at_present = "false"
+  else
+    created_at_present = "true"
+  end
+  steps %Q{
+    And the payload field "#{field}" matches the JSON fixture in "features/fixtures/sidekiq/payloads/handled_metadata_ca_#{created_at_present}.json"
+  }
+end
+
+Then("the payload field {string} matches the appropriate Sidekiq unhandled payload") do |field|
+  if ENV["SIDEKIQ_VERSION"] == "~> 2"
+    created_at_present = "false"
+  else
+    created_at_present = "true"
+  end
+  steps %Q{
+    And the payload field "#{field}" matches the JSON fixture in "features/fixtures/sidekiq/payloads/unhandled_metadata_ca_#{created_at_present}.json"
+  }
+end

data/features/support/env.rb

@@ -1,56 +1,23 @@
 require 'fileutils'
 
-Before do
-  find_default_docker_compose
-end
-
-def output_logs
-  $docker_services.each do |service|
-    logged_service = service[:service] == :all ? '' : service[:service]
-    command = "logs -t #{logged_service}"
-    begin
-      response = run_docker_compose_command(service[:file], command)
-    rescue => exception
-      response = "Couldn't retreive logs for #{service[:file]}:#{logged_service}"
-    end
-    STDOUT.puts response.is_a?(String) ? response : response.to_a
-  end
-end
-
 def install_fixture_gems
-  gem_dir = File.expand_path('../../../', __FILE__)
-  Dir.chdir(gem_dir) do
-    `rm bugsnag-*.gem` unless Dir.glob('bugsnag-*.gem').empty?
-    `gem build bugsnag.gemspec`
-    Dir.entries('features/fixtures').reject { |entry| ['.', '..'].include?(entry) }.each do |entry|
-      target_dir = "features/fixtures/#{entry}"
-      if File.directory?(target_dir)
-        `cp bugsnag-*.gem #{target_dir}`
-        `gem unpack #{target_dir}/bugsnag-*.gem --target #{target_dir}/temp-bugsnag-lib`
-      end
-    end
-    `rm bugsnag-*.gem`
-  end
-end
-
-# Added to ensure that multiple versions of Gems do not exist within the fixture folders,
-# which can be difficult to track down and clear up
-def remove_installed_gems
-  removal_targets = ['temp-bugsnag-lib', 'bugsnag-*.gem']
+  throw Error.new("Bugsnag.gem not found. Is this running in a docker-container?") unless File.exist?("/app/bugsnag.gem")
   Dir.entries('features/fixtures').reject { |entry| ['.', '..'].include?(entry) }.each do |entry|
     target_dir = "features/fixtures/#{entry}"
-    target_entries = []
-    removal_targets.each do |r_target|
-      target_entries += Dir.glob("#{target_dir}/#{r_target}")
-    end
-    target_entries.each do |d_target|
-      FileUtils.rm_rf(d_target)
+    if File.directory?(target_dir)
+      `cp /app/bugsnag.gem #{target_dir}`
+      `gem unpack #{target_dir}/bugsnag.gem --target #{target_dir}/temp-bugsnag-lib`
     end
   end
 end
 
-at_exit do
-  remove_installed_gems
+AfterConfiguration do |config|
+  install_fixture_gems
 end
 
-install_fixture_gems
+Before do
+  Docker.compose_project_name = "#{rand.to_s}:#{Time.new.strftime("%s")}"
+  Runner.environment.clear
+  Runner.environment["BUGSNAG_API_KEY"] = $api_key
+  Runner.environment["BUGSNAG_ENDPOINT"] = "http://maze-runner:#{MOCK_API_PORT}"
+end

data/lib/bugsnag.rb

@@ -33,6 +33,7 @@ require "bugsnag/breadcrumbs/validator"
 require "bugsnag/breadcrumbs/breadcrumb"
 require "bugsnag/breadcrumbs/breadcrumbs"
 
+# rubocop:todo Metrics/ModuleLength
 module Bugsnag
   LOCK = Mutex.new
   INTEGRATIONS = [:resque, :sidekiq, :mailman, :delayed_job, :shoryuken, :que, :mongo]
@@ -47,6 +48,12 @@ module Bugsnag
     def configure(validate_api_key=true)
       yield(configuration) if block_given?
 
+      # Create the session tracker if sessions are enabled to avoid the overhead
+      # of creating it on the first request. We skip this if we're not validating
+      # the API key as we use this internally before the user's configure block
+      # has run, so we don't know if sessions are enabled yet.
+      session_tracker if validate_api_key && configuration.auto_capture_sessions
+
       check_key_valid if validate_api_key
       check_endpoint_setup
 
@@ -63,7 +70,7 @@ module Bugsnag
         auto_notify = false
       end
 
-      return unless deliver_notification?(exception, auto_notify)
+      return unless should_deliver_notification?(exception, auto_notify)
 
       exception = NIL_EXCEPTION_DESCRIPTION if exception.nil?
 
@@ -71,6 +78,7 @@ module Bugsnag
 
       # If this is an auto_notify we yield the block before the any middleware is run
       yield(report) if block_given? && auto_notify
+
       if report.ignore?
         configuration.debug("Not notifying #{report.exceptions.last[:errorClass]} due to ignore being signified in auto_notify block")
         return
@@ -97,6 +105,7 @@ module Bugsnag
         # If this is not an auto_notify then the block was provided by the user. This should be the last
         # block that is run as it is the users "most specific" block.
         yield(report) if block_given? && !auto_notify
+
         if report.ignore?
           configuration.debug("Not notifying #{report.exceptions.last[:errorClass]} due to ignore being signified in user provided block")
           return
@@ -111,13 +120,7 @@ module Bugsnag
           report.severity_reason = initial_reason
         end
 
-        # Deliver
-        configuration.info("Notifying #{configuration.notify_endpoint} of #{report.exceptions.last[:errorClass]}")
-        options = {:headers => report.headers}
-        payload = ::JSON.dump(Bugsnag::Helpers.trim_if_needed(report.as_json))
-        Bugsnag::Delivery[configuration.delivery_method].deliver(configuration.notify_endpoint, payload, configuration, options)
-        report_summary = report.summary
-        leave_breadcrumb(report_summary[:error_class], report_summary, Bugsnag::Breadcrumbs::ERROR_BREADCRUMB_TYPE, :auto)
+        deliver_notification(report)
       end
     end
 
@@ -147,6 +150,7 @@ module Bugsnag
     # Configuration getters
     ##
     # Returns the client's Configuration object, or creates one if not yet created.
+    # @return [Configuration]
     def configuration
       @configuration = nil unless defined?(@configuration)
       @configuration || LOCK.synchronize { @configuration ||= Bugsnag::Configuration.new }
@@ -171,6 +175,8 @@ module Bugsnag
     # Allow access to "before notify" callbacks as an array.
     #
     # These callbacks will be called whenever an error notification is being made.
+    #
+    # @deprecated Use {Bugsnag#add_on_error} instead
     def before_notify_callbacks
       Bugsnag.configuration.request_data[:before_callbacks] ||= []
     end
@@ -211,27 +217,67 @@ module Bugsnag
       validator.validate(breadcrumb)
 
       # Skip if it's already invalid
-      unless breadcrumb.ignore?
-        # Run callbacks
-        configuration.before_breadcrumb_callbacks.each do |c|
-          c.arity > 0 ? c.call(breadcrumb) : c.call
-          break if breadcrumb.ignore?
-        end
+      return if breadcrumb.ignore?
 
-        # Return early if ignored
-        return if breadcrumb.ignore?
+      # Run callbacks
+      configuration.before_breadcrumb_callbacks.each do |c|
+        c.arity > 0 ? c.call(breadcrumb) : c.call
+        break if breadcrumb.ignore?
+      end
+
+      # Return early if ignored
+      return if breadcrumb.ignore?
+
+      # Validate again in case of callback alteration
+      validator.validate(breadcrumb)
+
+      # Add to breadcrumbs buffer if still valid
+      configuration.breadcrumbs << breadcrumb unless breadcrumb.ignore?
+    end
+
+    ##
+    # Add the given callback to the list of on_error callbacks
+    #
+    # The on_error callbacks will be called when an error is captured or reported
+    # and are passed a {Bugsnag::Report} object
+    #
+    # Returning false from an on_error callback will cause the error to be ignored
+    # and will prevent any remaining callbacks from being called
+    #
+    # @param callback [Proc]
+    # @return [void]
+    def add_on_error(callback)
+      configuration.add_on_error(callback)
+    end
 
-        # Validate again in case of callback alteration
-        validator.validate(breadcrumb)
+    ##
+    # Remove the given callback from the list of on_error callbacks
+    #
+    # Note that this must be the same Proc instance that was passed to
+    # {Bugsnag#add_on_error}, otherwise it will not be removed
+    #
+    # @param callback [Proc]
+    # @return [void]
+    def remove_on_error(callback)
+      configuration.remove_on_error(callback)
+    end
 
-        # Add to breadcrumbs buffer if still valid
-        configuration.breadcrumbs << breadcrumb unless breadcrumb.ignore?
+    ##
+    # Returns the client's Cleaner object, or creates one if not yet created.
+    #
+    # @api private
+    #
+    # @return [Cleaner]
+    def cleaner
+      @cleaner = nil unless defined?(@cleaner)
+      @cleaner || LOCK.synchronize do
+        @cleaner ||= Bugsnag::Cleaner.new(configuration)
       end
     end
 
     private
 
-    def deliver_notification?(exception, auto_notify)
+    def should_deliver_notification?(exception, auto_notify)
       reason = abort_reason(exception, auto_notify)
       configuration.debug(reason) unless reason.nil?
       reason.nil?
@@ -249,6 +295,32 @@ module Bugsnag
       end
     end
 
+    ##
+    # Deliver the notification to Bugsnag
+    #
+    # @param report [Report]
+    # @return void
+    def deliver_notification(report)
+      configuration.info("Notifying #{configuration.notify_endpoint} of #{report.exceptions.last[:errorClass]}")
+
+      payload = report_to_json(report)
+      options = {:headers => report.headers}
+
+      Bugsnag::Delivery[configuration.delivery_method].deliver(
+        configuration.notify_endpoint,
+        payload,
+        configuration,
+        options
+      )
+
+      leave_breadcrumb(
+        report.summary[:error_class],
+        report.summary,
+        Bugsnag::Breadcrumbs::ERROR_BREADCRUMB_TYPE,
+        :auto
+      )
+    end
+
     # Check if the API key is valid and warn (once) if it is not
     def check_key_valid
       @key_warning = false unless defined?(@key_warning)
@@ -273,7 +345,23 @@ module Bugsnag
         raise ArgumentError, "The session endpoint cannot be modified without the notify endpoint"
       end
     end
+
+    ##
+    # Convert the Report object to JSON
+    #
+    # We ensure the report is safe to send by removing recursion, fixing
+    # encoding errors and redacting metadata according to "meta_data_filters"
+    #
+    # @param report [Report]
+    # @return string
+    def report_to_json(report)
+      cleaned = cleaner.clean_object(report.as_json)
+      trimmed = Bugsnag::Helpers.trim_if_needed(cleaned)
+
+      ::JSON.dump(trimmed)
+    end
   end
 end
+# rubocop:enable Metrics/ModuleLength
 
 Bugsnag.load_integrations unless ENV["BUGSNAG_DISABLE_AUTOCONFIGURE"]

data/lib/bugsnag/breadcrumbs/breadcrumbs.rb

@@ -1,6 +1,4 @@
 module Bugsnag::Breadcrumbs
-  MAX_NAME_LENGTH = 30
-
   VALID_BREADCRUMB_TYPES = [
     ERROR_BREADCRUMB_TYPE = "error",
     MANUAL_BREADCRUMB_TYPE = "manual",

data/lib/bugsnag/breadcrumbs/validator.rb

@@ -15,12 +15,6 @@ module Bugsnag::Breadcrumbs
     #
     # @param breadcrumb [Bugsnag::Breadcrumbs::Breadcrumb] the breadcrumb to be validated
     def validate(breadcrumb)
-      # Check name length
-      if breadcrumb.name.size > Bugsnag::Breadcrumbs::MAX_NAME_LENGTH
-        @configuration.debug("Breadcrumb name trimmed to length #{Bugsnag::Breadcrumbs::MAX_NAME_LENGTH}.  Original name: #{breadcrumb.name}")
-        breadcrumb.name = breadcrumb.name.slice(0...Bugsnag::Breadcrumbs::MAX_NAME_LENGTH)
-      end
-
       # Check meta_data hash doesn't contain complex values
       breadcrumb.meta_data = breadcrumb.meta_data.select do |k, v|
         if valid_meta_data_type?(v)

data/lib/bugsnag/cleaner.rb

@@ -1,20 +1,76 @@
 require 'uri'
 
 module Bugsnag
+  # @api private
   class Cleaner
-    ENCODING_OPTIONS = {:invalid => :replace, :undef => :replace}.freeze
     FILTERED = '[FILTERED]'.freeze
     RECURSION = '[RECURSION]'.freeze
     OBJECT = '[OBJECT]'.freeze
     RAISED = '[RAISED]'.freeze
+    OBJECT_WITH_ID_AND_CLASS = '[OBJECT]: [Class]: %<class_name>s [ID]: %<id>d'.freeze
 
-    def initialize(filters)
-      @filters = Array(filters)
-      @deep_filters = @filters.any? {|f| f.kind_of?(Regexp) && f.to_s.include?("\\.".freeze) }
+    ##
+    # @param configuration [Configuration]
+    def initialize(configuration)
+      @configuration = configuration
     end
 
-    def clean_object(obj)
-      traverse_object(obj, {}, nil)
+    def clean_object(object)
+      @deep_filters = deep_filters?
+
+      traverse_object(object, {}, nil)
+    end
+
+    ##
+    # @param url [String]
+    # @return [String]
+    def clean_url(url)
+      return url if @configuration.meta_data_filters.empty?
+
+      uri = URI(url)
+      return url unless uri.query
+
+      query_params = uri.query.split('&').map { |pair| pair.split('=') }
+      query_params.map! do |key, val|
+        if filters_match?(key)
+          "#{key}=#{FILTERED}"
+        else
+          "#{key}=#{val}"
+        end
+      end
+
+      uri.query = query_params.join('&')
+      uri.to_s
+    end
+
+    private
+
+    ##
+    # This method calculates whether we need to filter deeply or not; i.e. whether
+    # we should match both with and without 'request.params'
+    #
+    # This is cached on the instance variable '@deep_filters' for performance
+    # reasons
+    #
+    # @return [Boolean]
+    def deep_filters?
+      @configuration.meta_data_filters.any? do |filter|
+        filter.is_a?(Regexp) && filter.to_s.include?("\\.".freeze)
+      end
+    end
+
+    def clean_string(str)
+      if defined?(str.encoding) && defined?(Encoding::UTF_8)
+        if str.encoding == Encoding::UTF_8
+          str.valid_encoding? ? str : str.encode('utf-16', invalid: :replace, undef: :replace).encode('utf-8')
+        else
+          str.encode('utf-8', invalid: :replace, undef: :replace)
+        end
+      elsif defined?(Iconv)
+        Iconv.conv('UTF-8//IGNORE', 'UTF-8', str) || str
+      else
+        str
+      end
     end
 
     def traverse_object(obj, seen, scope)
@@ -29,11 +85,22 @@ module Bugsnag
       value = case obj
       when Hash
         clean_hash = {}
-        obj.each do |k,v|
-          if filters_match_deeply?(k, scope)
-            clean_hash[k] = FILTERED
-          else
-            clean_hash[k] = traverse_object(v, seen, [scope, k].compact.join('.'))
+        obj.each do |k, v|
+          begin
+            current_scope = [scope, k].compact.join('.')
+
+            if filters_match_deeply?(k, current_scope)
+              clean_hash[k] = FILTERED
+            else
+              clean_hash[k] = traverse_object(v, seen, current_scope)
+            end
+          # If we get an error here, we assume the key needs to be filtered
+          # to avoid leaking things we shouldn't. We also remove the key itself
+          # because it may cause issues later e.g. when being converted to JSON
+          rescue StandardError
+            clean_hash[RAISED] = FILTERED
+          rescue SystemStackError
+            clean_hash[RECURSION] = FILTERED
           end
         end
         clean_hash
@@ -44,10 +111,23 @@ module Bugsnag
       when String
         clean_string(obj)
       else
-        str = obj.to_s rescue RAISED
+        # guard against objects that raise or blow the stack when stringified
+        begin
+          str = obj.to_s
+        rescue StandardError
+          str = RAISED
+        rescue SystemStackError
+          str = RECURSION
+        end
+
         # avoid leaking potentially sensitive data from objects' #inspect output
         if str =~ /#<.*>/
-          OBJECT
+          # Use id of the object if available
+          if obj.respond_to?(:id)
+            format(OBJECT_WITH_ID_AND_CLASS, class_name: obj.class, id: obj.id)
+          else
+            OBJECT
+          end
         else
           clean_string(str)
         end
@@ -57,67 +137,56 @@ module Bugsnag
       value
     end
 
-    def clean_string(str)
-      if defined?(str.encoding) && defined?(Encoding::UTF_8)
-        if str.encoding == Encoding::UTF_8
-          str.valid_encoding? ? str : str.encode('utf-16', ENCODING_OPTIONS).encode('utf-8')
+    ##
+    # @param key [String, #to_s]
+    # @return [Boolean]
+    def filters_match?(key)
+      str = key.to_s
+
+      @configuration.meta_data_filters.any? do |filter|
+        case filter
+        when Regexp
+          str.match(filter)
         else
-          str.encode('utf-8', ENCODING_OPTIONS)
+          str.include?(filter.to_s)
         end
-      elsif defined?(Iconv)
-        Iconv.conv('UTF-8//IGNORE', 'UTF-8', str) || str
-      else
-        str
       end
     end
 
-    def self.clean_object_encoding(obj)
-      new(nil).clean_object(obj)
-    end
+    ##
+    # If someone has a Rails filter like /^stuff\.secret/, it won't match
+    # "request.params.stuff.secret", so we try it both with and without the
+    # "request.params." bit.
+    #
+    # @param key [String, #to_s]
+    # @param scope [String]
+    # @return [Boolean]
+    def filters_match_deeply?(key, scope)
+      return false unless scope_should_be_filtered?(scope)
 
-    def clean_url(url)
-      return url if @filters.empty?
+      return true if filters_match?(key)
+      return false unless @deep_filters
 
-      uri = URI(url)
-      return url unless uri.query
+      return true if filters_match?(scope)
 
-      query_params = uri.query.split('&').map { |pair| pair.split('=') }
-      query_params.map! do |key, val|
-        if filters_match?(key)
-          "#{key}=#{FILTERED}"
+      @configuration.scopes_to_filter.any? do |scope_to_filter|
+        if scope.start_with?("#{scope_to_filter}.request.params.")
+          filters_match?(scope.sub("#{scope_to_filter}.request.params.", ''))
         else
-          "#{key}=#{val}"
+          filters_match?(scope.sub("#{scope_to_filter}.", ''))
         end
       end
-
-      uri.query = query_params.join('&')
-      uri.to_s
     end
 
-    private
-
-    def filters_match?(key)
-      str = key.to_s
-
-      @filters.any? do |f|
-        case f
-        when Regexp
-          str.match(f)
-        else
-          str.include?(f.to_s)
-        end
+    ##
+    # Should the given scope be filtered?
+    #
+    # @param scope [String]
+    # @return [Boolean]
+    def scope_should_be_filtered?(scope)
+      @configuration.scopes_to_filter.any? do |scope_to_filter|
+        scope.start_with?("#{scope_to_filter}.")
       end
     end
-
-    # If someone has a Rails filter like /^stuff\.secret/, it won't match "request.params.stuff.secret",
-    # so we try it both with and without the "request.params." bit.
-    def filters_match_deeply?(key, scope)
-      return true if filters_match?(key)
-      return false unless @deep_filters
-
-      long = [scope, key].compact.join('.')
-      short = long.sub(/^request\.params\./, '')
-      filters_match?(long) || filters_match?(short)
-    end
   end
 end