airbrake-ruby 3.2.2-java

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

@@ -0,0 +1,63 @@
+module Airbrake
+  class Config
+    # Validates values of {Airbrake::Config} options.
+    #
+    # @api private
+    # @since v1.5.0
+    class Validator
+      # @return [String]
+      REQUIRED_KEY_MSG = ':project_key is required'.freeze
+
+      # @return [String]
+      REQUIRED_ID_MSG = ':project_id is required'.freeze
+
+      # @return [String]
+      WRONG_ENV_TYPE_MSG = "the 'environment' option must be configured " \
+                           "with a Symbol (or String), but '%s' was provided: " \
+                           '%s'.freeze
+
+      # @return [Array<Class>] the list of allowed types to configure the
+      #   environment option
+      VALID_ENV_TYPES = [NilClass, String, Symbol].freeze
+
+      # @return [String] error message, if validator was able to find any errors
+      #   in the config
+      attr_reader :error_message
+
+      # Validates given config and stores error message, if any errors were
+      # found.
+      #
+      # @param config [Airbrake::Config] the config to validate
+      def initialize(config)
+        @config = config
+        @error_message = nil
+      end
+
+      # @return [Boolean]
+      def valid_project_id?
+        valid = @config.project_id.to_i > 0
+        @error_message = REQUIRED_ID_MSG unless valid
+        valid
+      end
+
+      # @return [Boolean]
+      def valid_project_key?
+        valid = @config.project_key.is_a?(String) && !@config.project_key.empty?
+        @error_message = REQUIRED_KEY_MSG unless valid
+        valid
+      end
+
+      # @return [Boolean]
+      def valid_environment?
+        environment = @config.environment
+        valid = VALID_ENV_TYPES.any? { |type| environment.is_a?(type) }
+
+        unless valid
+          @error_message = format(WRONG_ENV_TYPE_MSG, environment.class, environment)
+        end
+
+        valid
+      end
+    end
+  end
+end

data/lib/airbrake-ruby/deploy_notifier.rb

@@ -0,0 +1,47 @@
+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
+    # @param [Airbrake::Config] config
+    def initialize(config)
+      @config =
+        if config.is_a?(Config)
+          config
+        else
+          loc = caller_locations(1..1).first
+          signature = "#{self.class.name}##{__method__}"
+          warn(
+            "#{loc.path}:#{loc.lineno}: warning: passing a Hash to #{signature} " \
+            'is deprecated. Pass `Airbrake::Config` instead'
+          )
+          Config.new(config)
+        end
+
+      @sender = SyncSender.new(@config)
+    end
+
+    # @see Airbrake.create_deploy
+    def notify(deploy_info, promise = Airbrake::Promise.new)
+      if @config.ignored_environment?
+        return promise.reject("The '#{@config.environment}' environment is ignored")
+      end
+
+      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,48 @@
+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
+
+    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)
+    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 }
+
+      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,45 @@
+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
+      def initialize(logger)
+        @logger = logger
+        @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,90 @@
+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
+
+      # @param [Logger] logger
+      # @param [String] root_directory
+      def initialize(logger, root_directory)
+        @git_path = File.join(root_directory, '.git')
+        @logger = logger
+        @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
+
+      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
+
+      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