airbrake-ruby 4.7.0

data/lib/airbrake-ruby/config/validator.rb

@@ -0,0 +1,91 @@
+module Airbrake
+  class Config
+    # Validator validates values of {Airbrake::Config} options. A valid config
+    # is a config that guarantees that data can be sent to Airbrake given its
+    # configuration.
+    #
+    # @api private
+    # @since v1.5.0
+    class Validator
+      # @return [Array<Class>] the list of allowed types to configure the
+      #   environment option
+      VALID_ENV_TYPES = [NilClass, String, Symbol].freeze
+
+      class << self
+        # @param [Airbrake::Config] config
+        # @since v4.1.0
+        def validate(config)
+          promise = Airbrake::Promise.new
+
+          unless valid_project_id?(config)
+            return promise.reject(':project_id is required')
+          end
+
+          unless valid_project_key?(config)
+            return promise.reject(':project_key is required')
+          end
+
+          unless valid_environment?(config)
+            return promise.reject(
+              "the 'environment' option must be configured " \
+              "with a Symbol (or String), but '#{config.environment.class}' was " \
+              "provided: #{config.environment}"
+            )
+          end
+
+          promise.resolve(:ok)
+        end
+
+        # Whether the given +config+ allows sending data to Airbrake. It doesn't
+        # matter if it's valid or invalid.
+        #
+        # @param [Airbrake::Config] config
+        # @since v4.1.0
+        def check_notify_ability(config)
+          promise = Airbrake::Promise.new
+
+          if ignored_environment?(config)
+            return promise.reject(
+              "current environment '#{config.environment}' is ignored"
+            )
+          end
+
+          promise.resolve(:ok)
+        end
+
+        private
+
+        def valid_project_id?(config)
+          return true if config.project_id.to_i > 0
+          false
+        end
+
+        def valid_project_key?(config)
+          return false unless config.project_key.is_a?(String)
+          return false if config.project_key.empty?
+          true
+        end
+
+        def valid_environment?(config)
+          VALID_ENV_TYPES.any? { |type| config.environment.is_a?(type) }
+        end
+
+        def ignored_environment?(config)
+          if config.ignore_environments.any? && config.environment.nil?
+            config.logger.warn(
+              "#{LOG_LABEL} the 'environment' option is not set, " \
+              "'ignore_environments' has no effect"
+            )
+          end
+
+          return false if config.ignore_environments.none? || !config.environment
+
+          env = config.environment.to_s
+          config.ignore_environments.any? do |pattern|
+            pattern.is_a?(Regexp) ? env.match(pattern) : env == pattern.to_s
+          end
+        end
+      end
+    end
+  end
+end

data/lib/airbrake-ruby/deploy_notifier.rb

@@ -0,0 +1,36 @@
+module Airbrake
+  # DeployNotifier sends deploy information to Airbrake. The information
+  # consists of:
+  # - environment
+  # - username
+  # - repository
+  # - revision
+  # - version
+  #
+  # @api public
+  # @since v3.2.0
+  class DeployNotifier
+    include Inspectable
+
+    def initialize
+      @config = Airbrake::Config.instance
+      @sender = SyncSender.new
+    end
+
+    # @see Airbrake.notify_deploy
+    def notify(deploy_info)
+      promise = @config.check_configuration
+      return promise if promise.rejected?
+
+      promise = Airbrake::Promise.new
+      deploy_info[:environment] ||= @config.environment
+      @sender.send(
+        deploy_info,
+        promise,
+        URI.join(@config.host, "api/v4/projects/#{@config.project_id}/deploys")
+      )
+
+      promise
+    end
+  end
+end

data/lib/airbrake-ruby/file_cache.rb

@@ -0,0 +1,54 @@
+module Airbrake
+  # Extremely simple global cache.
+  #
+  # @api private
+  # @since v2.4.1
+  module FileCache
+    # @return [Integer]
+    MAX_SIZE = 50
+
+    # @return [Mutex]
+    MUTEX = Mutex.new
+
+    # Associates the value given by +value+ with the key given by +key+. Deletes
+    # entries that exceed +MAX_SIZE+.
+    #
+    # @param [Object] key
+    # @param [Object] value
+    # @return [Object] the corresponding value
+    def self.[]=(key, value)
+      MUTEX.synchronize do
+        data[key] = value
+        data.delete(data.keys.first) if data.size > MAX_SIZE
+      end
+    end
+
+    # Retrieve an object from the cache.
+    #
+    # @param [Object] key
+    # @return [Object] the corresponding value
+    def self.[](key)
+      MUTEX.synchronize do
+        data[key]
+      end
+    end
+
+    # Checks whether the cache is empty. Needed only for the test suite.
+    #
+    # @return [Boolean]
+    def self.empty?
+      data.empty?
+    end
+
+    # @since ?.?.?
+    # @return [void]
+    def self.reset
+      @data = {}
+    end
+
+    def self.data
+      @data ||= {}
+    end
+    private_class_method :data
+  end
+end

data/lib/airbrake-ruby/filter_chain.rb

@@ -0,0 +1,95 @@
+module Airbrake
+  # FilterChain represents an ordered array of filters.
+  #
+  # A filter is an object that responds to <b>#call</b> (typically a Proc or a
+  # class that implements the call method). The <b>#call</b> method must accept
+  # exactly one argument: an object to be filtered.
+  #
+  # When you add a new filter to the chain, it gets inserted according to its
+  # <b>weight</b>. Smaller weight means the filter will be somewhere in the
+  # beginning of the array. Larger - in the end. If a filter doesn't implement
+  # weight, the chain assumes it's equal to 0.
+  #
+  # @example
+  #   class MyFilter
+  #     attr_reader :weight
+  #
+  #     def initialize
+  #       @weight = 1
+  #     end
+  #
+  #     def call(obj)
+  #       puts 'Filtering...'
+  #       obj[:data] = '[Filtered]'
+  #     end
+  #   end
+  #
+  #   filter_chain = FilterChain.new
+  #   filter_chain.add_filter(MyFilter)
+  #
+  #   filter_chain.refine(obj)
+  #   #=> Filtering...
+  #
+  # @see Airbrake.add_filter
+  # @api private
+  # @since v1.0.0
+  class FilterChain
+    # @return [Integer]
+    DEFAULT_WEIGHT = 0
+
+    def initialize
+      @filters = []
+    end
+
+    # Adds a filter to the filter chain. Sorts filters by weight.
+    #
+    # @param [#call] filter The filter object (proc, class, module, etc)
+    # @return [void]
+    def add_filter(filter)
+      @filters = (@filters << filter).sort_by do |f|
+        f.respond_to?(:weight) ? f.weight : DEFAULT_WEIGHT
+      end.reverse!
+    end
+
+    # Deletes a filter from the the filter chain.
+    #
+    # @param [Class] filter_class The class of the filter you want to delete
+    # @return [void]
+    # @since v3.1.0
+    def delete_filter(filter_class)
+      index = @filters.index { |f| f.class.name == filter_class.name }
+      @filters.delete_at(index) if index
+    end
+
+    # Applies all the filters in the filter chain to the given notice. Does not
+    # filter ignored notices.
+    #
+    # @param [Airbrake::Notice] notice The notice to be filtered
+    # @return [void]
+    # @todo Make it work with anything, not only notices
+    def refine(notice)
+      @filters.each do |filter|
+        break if notice.ignored?
+        filter.call(notice)
+      end
+    end
+
+    # @return [String] customized inspect to lessen the amount of clutter
+    def inspect
+      @filters.map(&:class).to_s
+    end
+
+    # @return [String] {#inspect} for PrettyPrint
+    def pretty_print(q)
+      q.text('[')
+
+      # Make nesting of the first element consistent on JRuby and MRI.
+      q.nest(2) { q.breakable } if @filters.any?
+
+      q.nest(2) do
+        q.seplist(@filters) { |f| q.pp(f.class) }
+      end
+      q.text(']')
+    end
+  end
+end

data/lib/airbrake-ruby/filters/context_filter.rb

@@ -0,0 +1,29 @@
+module Airbrake
+  module Filters
+    # Adds user context to the notice object. Clears the context after it's
+    # attached.
+    #
+    # @api private
+    # @since v2.9.0
+    class ContextFilter
+      # @return [Integer]
+      attr_reader :weight
+
+      def initialize(context)
+        @context = context
+        @weight = 119
+        @mutex = Mutex.new
+      end
+
+      # @macro call_filter
+      def call(notice)
+        @mutex.synchronize do
+          return if @context.empty?
+
+          notice[:params][:airbrake_context] = @context.dup
+          @context.clear
+        end
+      end
+    end
+  end
+end

data/lib/airbrake-ruby/filters/dependency_filter.rb

@@ -0,0 +1,31 @@
+module Airbrake
+  module Filters
+    # Attaches loaded dependencies to the notice object.
+    #
+    # @api private
+    # @since v2.10.0
+    class DependencyFilter
+      def initialize
+        @weight = 117
+      end
+
+      # @macro call_filter
+      def call(notice)
+        deps = {}
+        Gem.loaded_specs.map.with_object(deps) do |(name, spec), h|
+          h[name] = "#{spec.version}#{git_version(spec)}"
+        end
+
+        notice[:context][:versions] = {} unless notice[:context].key?(:versions)
+        notice[:context][:versions][:dependencies] = deps
+      end
+
+      private
+
+      def git_version(spec)
+        return unless spec.respond_to?(:git_version) || spec.git_version
+        spec.git_version.to_s
+      end
+    end
+  end
+end

data/lib/airbrake-ruby/filters/exception_attributes_filter.rb

@@ -0,0 +1,46 @@
+module Airbrake
+  module Filters
+    # ExceptionAttributesFilter attempts to call `#to_airbrake` on the stashed
+    # exception and attaches returned data to the notice object.
+    #
+    # @api private
+    # @since v2.10.0
+    class ExceptionAttributesFilter
+      include Loggable
+
+      def initialize
+        @weight = 118
+      end
+
+      # @macro call_filter
+      def call(notice)
+        exception = notice.stash[:exception]
+        return unless exception.respond_to?(:to_airbrake)
+
+        attributes = nil
+        begin
+          attributes = exception.to_airbrake
+        rescue StandardError => ex
+          logger.error(
+            "#{LOG_LABEL} #{exception.class}#to_airbrake failed. #{ex.class}: #{ex}"
+          )
+        end
+
+        unless attributes.is_a?(Hash)
+          logger.error(
+            "#{LOG_LABEL} #{self.class}: wanted Hash, got #{attributes.class}"
+          )
+          return
+        end
+
+        attributes.each do |key, attrs|
+          if notice[key]
+            notice[key].merge!(attrs)
+          else
+            notice[key] = attrs
+          end
+        end
+      end
+    end
+  end
+end

data/lib/airbrake-ruby/filters/gem_root_filter.rb

@@ -0,0 +1,33 @@
+module Airbrake
+  module Filters
+    # Replaces paths to gems with a placeholder.
+    # @api private
+    class GemRootFilter
+      # @return [String]
+      GEM_ROOT_LABEL = '/GEM_ROOT'.freeze
+
+      # @return [Integer]
+      attr_reader :weight
+
+      def initialize
+        @weight = 120
+      end
+
+      # @macro call_filter
+      def call(notice)
+        return unless defined?(Gem)
+
+        notice[:errors].each do |error|
+          Gem.path.each do |gem_path|
+            error[:backtrace].each do |frame|
+              # If the frame is unparseable, then 'file' is nil, thus nothing to
+              # filter (all frame's data is in 'function' instead).
+              next unless (file = frame[:file])
+              frame[:file] = file.sub(/\A#{gem_path}/, GEM_ROOT_LABEL)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/airbrake-ruby/filters/git_last_checkout_filter.rb

@@ -0,0 +1,92 @@
+require 'date'
+
+module Airbrake
+  module Filters
+    # Attaches git checkout info to `context`. The info includes:
+    #   * username
+    #   * email
+    #   * revision
+    #   * time
+    #
+    # This information is used to track deploys automatically.
+    #
+    # @api private
+    # @since v2.12.0
+    class GitLastCheckoutFilter
+      # @return [Integer]
+      attr_reader :weight
+
+      # @return [Integer] least possible amount of columns in git's `logs/HEAD`
+      #   file (checkout information is omitted)
+      MIN_HEAD_COLS = 6
+
+      include Loggable
+
+      # @param [String] root_directory
+      def initialize(root_directory)
+        @git_path = File.join(root_directory, '.git')
+        @weight = 116
+        @last_checkout = nil
+      end
+
+      # @macro call_filter
+      def call(notice)
+        return if notice[:context].key?(:lastCheckout)
+
+        if @last_checkout
+          notice[:context][:lastCheckout] = @last_checkout
+          return
+        end
+
+        return unless File.exist?(@git_path)
+        return unless (checkout = last_checkout)
+        notice[:context][:lastCheckout] = checkout
+      end
+
+      private
+
+      # rubocop:disable Metrics/AbcSize
+      def last_checkout
+        return unless (line = last_checkout_line)
+
+        parts = line.chomp.split("\t").first.split(' ')
+        if parts.size < MIN_HEAD_COLS
+          logger.error(
+            "#{LOG_LABEL} Airbrake::#{self.class.name}: can't parse line: #{line}"
+          )
+          return
+        end
+
+        author = parts[2..-4]
+        @last_checkout = {
+          username: author[0..1].join(' '),
+          email: parts[-3][1..-2],
+          revision: parts[1],
+          time: timestamp(parts[-2].to_i)
+        }
+      end
+      # rubocop:enable Metrics/AbcSize
+
+      def last_checkout_line
+        head_path = File.join(@git_path, 'logs', 'HEAD')
+        return unless File.exist?(head_path)
+
+        last_line = nil
+        IO.foreach(head_path) do |line|
+          last_line = line if checkout_line?(line)
+        end
+        last_line
+      end
+
+      def checkout_line?(line)
+        line.include?("\tclone:") ||
+          line.include?("\tpull:") ||
+          line.include?("\tcheckout:")
+      end
+
+      def timestamp(utime)
+        Time.at(utime).to_datetime.rfc3339
+      end
+    end
+  end
+end