bugsnag 4.2.1 → 6.27.1

data/lib/bugsnag/stacktrace.rb

@@ -0,0 +1,82 @@
+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]+))?\)$/
+
+    ##
+    # Process a backtrace and the configuration into a parsed stacktrace.
+    #
+    # @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|
+        # 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
+
+        next if file.nil?
+
+        # Expand relative paths
+        file = File.realpath(file) rescue file
+
+        # Generate the stacktrace line hash
+        trace_hash = { lineNumber: line_str.to_i }
+
+        # 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 vendor_path?(configuration, file)
+        end
+
+        # Strip common gem path prefixes
+        if defined?(Gem)
+          Gem.path.each do |path|
+            file.sub!("#{path}/", "")
+          end
+        end
+
+        trace_hash[:file] = file
+
+        # Add a method if we have it
+        trace_hash[:method] = method if method && (method =~ /^__bind/).nil?
+
+        # 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
+
+        trace_hash
+      end.compact
+
+      code_extractor.extract! if configuration.send_code
+
+      processed_backtrace
+    end
+
+    # @api private
+    def self.vendor_path?(configuration, file_path)
+      return true if configuration.vendor_path && file_path.match(configuration.vendor_path)
+
+      configuration.vendor_paths.any? do |vendor_path|
+        file_path.start_with?("#{vendor_path.sub(/\/$/, '')}/")
+      end
+    end
+  end
+end

data/lib/bugsnag/tasks/bugsnag.rake

@@ -1,82 +1,14 @@
 require "bugsnag"
 
 namespace :bugsnag do
-  desc "Notify Bugsnag of a new deploy."
-  task :deploy do
-    api_key = ENV["BUGSNAG_API_KEY"]
-    release_stage = ENV["BUGSNAG_RELEASE_STAGE"]
-    app_version = ENV["BUGSNAG_APP_VERSION"]
-    revision = ENV["BUGSNAG_REVISION"]
-    repository = ENV["BUGSNAG_REPOSITORY"]
-    branch = ENV["BUGSNAG_BRANCH"]
-
-    Rake::Task["load"].invoke unless api_key
-
-    Bugsnag::Deploy.notify({
-      :api_key => api_key,
-      :release_stage => release_stage,
-      :app_version => app_version,
-      :revision => revision,
-      :repository => repository,
-      :branch => branch
-    })
-  end
-
   desc "Send a test exception to Bugsnag."
   task :test_exception => :load do
     begin
       raise RuntimeError.new("Bugsnag test exception")
     rescue => e
-      Bugsnag.notify(e, {:context => "rake#test_exception"})
-    end
-  end
-
-  desc "Show the bugsnag middleware stack"
-  task :middleware => :load do
-    Bugsnag.configuration.middleware.each {|m| puts m.to_s}
-  end
-
-  namespace :heroku do
-    desc "Add a heroku deploy hook to notify Bugsnag of deploys"
-    task :add_deploy_hook => :load do
-      # Wrapper to run command safely even in bundler
-      run_command = lambda { |command|
-        defined?(Bundler.with_clean_env) ? Bundler.with_clean_env { `#{command}` } : `#{command}`
-      }
-
-      # Fetch heroku config settings
-      config_command = "heroku config --shell"
-      config_command += " --app #{ENV["HEROKU_APP"]}" if ENV["HEROKU_APP"]
-      heroku_env = run_command.call(config_command).split(/[\n\r]/).each_with_object({}) do |c, obj|
-        k,v = c.split("=")
-        obj[k] = (v.nil? || v.strip.empty?) ? nil : v
-      end
-
-      # Check for Bugsnag API key (required)
-      api_key = heroku_env["BUGSNAG_API_KEY"] || Bugsnag.configuration.api_key || ENV["BUGSNAG_API_KEY"]
-      unless api_key
-        puts "Error: No API key found, have you run 'heroku config:set BUGSNAG_API_KEY=your-api-key'?"
-        next
+      Bugsnag.notify(e) do |report|
+        report.automatic_context = "rake#test_exception"
       end
-
-      # Build the request, making use of deploy hook variables
-      # (https://devcenter.heroku.com/articles/deploy-hooks#customizing-messages)
-      params = {
-        :apiKey => api_key,
-        :branch => "master",
-        :revision => "{{head_long}}",
-        :releaseStage => heroku_env["RAILS_ENV"] || ENV["RAILS_ENV"] || "production"
-      }
-      repo = `git config --get remote.origin.url`.strip
-      params[:repository] = repo unless repo.empty?
-
-      # Add the hook
-      url = "https://notify.bugsnag.com/deploy?" + params.map {|k,v| "#{k}=#{v}"}.join("&")
-      command = "heroku addons:add deployhooks:http --url=\"#{url}\""
-      command += " --app #{ENV["HEROKU_APP"]}" if ENV["HEROKU_APP"]
-
-      puts "$ #{command}"
-      run_command.call(command)
     end
   end
 end

data/lib/bugsnag/utility/circular_buffer.rb

@@ -0,0 +1,62 @@
+module Bugsnag::Utility
+  ##
+  # A container class with a maximum size, that removes oldest items as required.
+  #
+  # @api private
+  class CircularBuffer
+    include Enumerable
+
+    # @return [Integer] the current maximum allowable number of items
+    attr_reader :max_items
+
+    ##
+    # @param max_items [Integer] the initial maximum number of items
+    def initialize(max_items = 25)
+      @max_items = max_items
+      @buffer = []
+    end
+
+    ##
+    # Adds an item to the circular buffer
+    #
+    # If this causes the buffer to exceed its maximum items, the oldest item will be removed
+    #
+    # @param item [Object] the item to add to the buffer
+    # @return [self] returns itself to allow method chaining
+    def <<(item)
+      @buffer << item
+      trim_buffer
+      self
+    end
+
+    ##
+    # Iterates over the buffer
+    #
+    # @yield [Object] sequentially gives stored items to the block
+    def each(&block)
+      @buffer.each(&block)
+    end
+
+    ##
+    # Sets the maximum allowable number of items
+    #
+    # If the current number of items exceeds the new maximum, oldest items will be removed
+    # until this is no longer the case
+    #
+    # @param new_max_items [Integer] the new allowed item maximum
+    def max_items=(new_max_items)
+      @max_items = new_max_items
+      trim_buffer
+    end
+
+    private
+
+    ##
+    # Trims the buffer down to the current maximum allowable item number
+    def trim_buffer
+      trim_size = @buffer.size - @max_items
+      trim_size = 0 if trim_size < 0
+      @buffer.shift(trim_size)
+    end
+  end
+end

data/lib/bugsnag/utility/duplicator.rb

@@ -0,0 +1,124 @@
+module Bugsnag::Utility
+  # @api private
+  class Duplicator
+    class << self
+      ##
+      # Duplicate (deep clone) the given object
+      #
+      # @param object [Object]
+      # @param seen_objects [Hash<String, Object>]
+      # @return [Object]
+      def duplicate(object, seen_objects = {})
+        case object
+        # return immutable & non-duplicatable objects as-is
+        when Symbol, Numeric, Method, TrueClass, FalseClass, NilClass
+          object
+        when Array
+          duplicate_array(object, seen_objects)
+        when Hash
+          duplicate_hash(object, seen_objects)
+        when Range
+          duplicate_range(object, seen_objects)
+        when Struct
+          duplicate_struct(object, seen_objects)
+        else
+          duplicate_generic_object(object, seen_objects)
+        end
+      rescue StandardError
+        object
+      end
+
+      private
+
+      def duplicate_array(array, seen_objects)
+        id = array.object_id
+
+        return seen_objects[id] if seen_objects.key?(id)
+
+        copy = array.dup
+        seen_objects[id] = copy
+
+        copy.map! do |value|
+          duplicate(value, seen_objects)
+        end
+
+        copy
+      end
+
+      def duplicate_hash(hash, seen_objects)
+        id = hash.object_id
+
+        return seen_objects[id] if seen_objects.key?(id)
+
+        copy = {}
+        seen_objects[id] = copy
+
+        hash.each do |key, value|
+          copy[duplicate(key, seen_objects)] = duplicate(value, seen_objects)
+        end
+
+        copy
+      end
+
+      ##
+      # Ranges are immutable but the values they contain may not be
+      #
+      # For example, a range of "a".."z" can be mutated: range.first.upcase!
+      def duplicate_range(range, seen_objects)
+        id = range.object_id
+
+        return seen_objects[id] if seen_objects.key?(id)
+
+        begin
+          copy = range.class.new(
+            duplicate(range.first, seen_objects),
+            duplicate(range.last, seen_objects),
+            range.exclude_end?
+          )
+        rescue StandardError
+          copy = range.dup
+        end
+
+        seen_objects[id] = copy
+      end
+
+      def duplicate_struct(struct, seen_objects)
+        id = struct.object_id
+
+        return seen_objects[id] if seen_objects.key?(id)
+
+        copy = struct.dup
+        seen_objects[id] = copy
+
+        struct.each_pair do |attribute, value|
+          begin
+            copy.send("#{attribute}=", duplicate(value, seen_objects))
+          rescue StandardError # rubocop:todo Lint/SuppressedException
+          end
+        end
+
+        copy
+      end
+
+      def duplicate_generic_object(object, seen_objects)
+        id = object.object_id
+
+        return seen_objects[id] if seen_objects.key?(id)
+
+        copy = object.dup
+        seen_objects[id] = copy
+
+        begin
+          copy.instance_variables.each do |variable|
+            value = copy.instance_variable_get(variable)
+
+            copy.instance_variable_set(variable, duplicate(value, seen_objects))
+          end
+        rescue StandardError # rubocop:todo Lint/SuppressedException
+        end
+
+        copy
+      end
+    end
+  end
+end

data/lib/bugsnag/utility/feature_data_store.rb

@@ -0,0 +1,41 @@
+module Bugsnag::Utility
+  # @abstract Requires a #feature_flag_delegate method returning a
+  #   {Bugsnag::Utility::FeatureFlagDelegate}
+  module FeatureDataStore
+    # Add a feature flag with the given name & variant
+    #
+    # @param name [String]
+    # @param variant [String, nil]
+    # @return [void]
+    def add_feature_flag(name, variant = nil)
+      feature_flag_delegate.add(name, variant)
+    end
+
+    # Merge the given array of FeatureFlag instances into the stored feature
+    # flags
+    #
+    # New flags will be appended to the array. Flags with the same name will be
+    # overwritten, but their position in the array will not change
+    #
+    # @param feature_flags [Array<Bugsnag::FeatureFlag>]
+    # @return [void]
+    def add_feature_flags(feature_flags)
+      feature_flag_delegate.merge(feature_flags)
+    end
+
+    # Remove the stored flag with the given name
+    #
+    # @param name [String]
+    # @return [void]
+    def clear_feature_flag(name)
+      feature_flag_delegate.remove(name)
+    end
+
+    # Remove all the stored flags
+    #
+    # @return [void]
+    def clear_feature_flags
+      feature_flag_delegate.clear
+    end
+  end
+end

data/lib/bugsnag/utility/feature_flag_delegate.rb

@@ -0,0 +1,89 @@
+module Bugsnag::Utility
+  # @api private
+  class FeatureFlagDelegate
+    def initialize
+      # feature flags are stored internally in a hash of "name" => <FeatureFlag>
+      # we don't use a Set because new feature flags should overwrite old ones
+      # that share a name, but FeatureFlag equality also uses the variant
+      @storage = {}
+    end
+
+    def initialize_dup(original)
+      super
+
+      # copy the internal storage when 'dup' is called
+      @storage = @storage.dup
+    end
+
+    # Add a feature flag with the given name & variant
+    #
+    # @param name [String]
+    # @param variant [String, nil]
+    # @return [void]
+    def add(name, variant)
+      flag = Bugsnag::FeatureFlag.new(name, variant)
+
+      return unless flag.valid?
+
+      @storage[flag.name] = flag
+    end
+
+    # Merge the given array of FeatureFlag instances into the stored feature
+    # flags
+    #
+    # New flags will be appended to the array. Flags with the same name will be
+    # overwritten, but their position in the array will not change
+    #
+    # @param feature_flags [Array<Bugsnag::FeatureFlag>]
+    # @return [void]
+    def merge(feature_flags)
+      feature_flags.each do |flag|
+        next unless flag.is_a?(Bugsnag::FeatureFlag)
+        next unless flag.valid?
+
+        @storage[flag.name] = flag
+      end
+    end
+
+    # Remove the stored flag with the given name
+    #
+    # @param name [String]
+    # @return [void]
+    def remove(name)
+      @storage.delete(name)
+    end
+
+    # Remove all the stored flags
+    #
+    # @return [void]
+    def clear
+      @storage.clear
+    end
+
+    # Get an array of FeatureFlag instances
+    #
+    # @example
+    #   [
+    #     <#Bugsnag::FeatureFlag>,
+    #     <#Bugsnag::FeatureFlag>,
+    #   ]
+    #
+    # @return [Array<Bugsnag::FeatureFlag>]
+    def to_a
+      @storage.values
+    end
+
+    # Get the feature flags in their JSON representation
+    #
+    # @example
+    #   [
+    #     { "featureFlag" => "name", "variant" => "variant" },
+    #     { "featureFlag" => "another name" },
+    #   ]
+    #
+    # @return [Array<Hash{String => String}>]
+    def as_json
+      to_a.map(&:to_h)
+    end
+  end
+end

data/lib/bugsnag/utility/metadata_delegate.rb

@@ -0,0 +1,102 @@
+module Bugsnag::Utility
+  # @api private
+  class MetadataDelegate
+    # nil is a valid metadata value, so we need a sentinel object so we can tell
+    # if the value parameter has been provided
+    NOT_PROVIDED = Object.new
+
+    ##
+    # Add values to metadata
+    #
+    # @overload add_metadata(metadata, section, data)
+    #   Merges data into the given section of metadata
+    #   @param metadata [Hash] The metadata hash to operate on
+    #   @param section [String, Symbol]
+    #   @param data [Hash]
+    #
+    # @overload add_metadata(metadata, section, key, value)
+    #   Sets key to value in the given section of metadata. If the value is nil
+    #   the key will be deleted
+    #   @param metadata [Hash] The metadata hash to operate on
+    #   @param section [String, Symbol]
+    #   @param key [String, Symbol]
+    #   @param value
+    #
+    # @return [void]
+    def add_metadata(metadata, section, key_or_data, value = NOT_PROVIDED)
+      case value
+      when NOT_PROVIDED
+        merge_metadata(metadata, section, key_or_data)
+      when nil
+        clear_metadata(metadata, section, key_or_data)
+      else
+        overwrite_metadata(metadata, section, key_or_data, value)
+      end
+    end
+
+    ##
+    # Clear values from metadata
+    #
+    # @overload clear_metadata(metadata, section)
+    #   Clears the given section of metadata
+    #   @param metadata [Hash] The metadata hash to operate on
+    #   @param section [String, Symbol]
+    #
+    # @overload clear_metadata(metadata, section, key)
+    #   Clears the key in the given section of metadata
+    #   @param metadata [Hash] The metadata hash to operate on
+    #   @param section [String, Symbol]
+    #   @param key [String, Symbol]
+    #
+    # @return [void]
+    def clear_metadata(metadata, section, key = nil)
+      if key.nil?
+        metadata.delete(section)
+      elsif metadata[section]
+        metadata[section].delete(key)
+      end
+    end
+
+    private
+
+    ##
+    # Merge new metadata into the existing metadata
+    #
+    # Any keys with a 'nil' value in the new metadata will be deleted from the
+    # existing metadata
+    #
+    # @param existing_metadata [Hash]
+    # @param section [String, Symbol]
+    # @param new_metadata [Hash]
+    # @return [void]
+    def merge_metadata(existing_metadata, section, new_metadata)
+      return unless new_metadata.is_a?(Hash)
+
+      existing_metadata[section] ||= {}
+      data = existing_metadata[section]
+
+      new_metadata.each do |key, value|
+        if value.nil?
+          data.delete(key)
+        else
+          data[key] = value
+        end
+      end
+    end
+
+    ##
+    # Overwrite the value in metadata's section & key
+    #
+    # @param metadata [Hash]
+    # @param section [String, Symbol]
+    # @param key [String, Symbol]
+    # @param value
+    # @return [void]
+    def overwrite_metadata(metadata, section, key, value)
+      return unless key.is_a?(String) || key.is_a?(Symbol)
+
+      metadata[section] ||= {}
+      metadata[section][key] = value
+    end
+  end
+end