airbrake-ruby 3.2.2-java

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

@@ -0,0 +1,23 @@
+module Airbrake
+  module Filters
+    # Skip over SystemExit exceptions, because they're just noise.
+    # @api private
+    class SystemExitFilter
+      # @return [String]
+      SYSTEM_EXIT_TYPE = 'SystemExit'.freeze
+
+      # @return [Integer]
+      attr_reader :weight
+
+      def initialize
+        @weight = 130
+      end
+
+      # @macro call_filter
+      def call(notice)
+        return if notice[:errors].none? { |error| error[:type] == SYSTEM_EXIT_TYPE }
+        notice.ignore!
+      end
+    end
+  end
+end

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

@@ -0,0 +1,92 @@
+module Airbrake
+  module Filters
+    # Attaches thread & fiber local variables along with general thread
+    # information.
+    # @api private
+    class ThreadFilter
+      # @return [Integer]
+      attr_reader :weight
+
+      # @return [Array<Class>] the list of classes that can be safely converted
+      #   to JSON
+      SAFE_CLASSES = [
+        NilClass,
+        TrueClass,
+        FalseClass,
+        String,
+        Symbol,
+        Regexp,
+        Numeric
+      ].freeze
+
+      # Variables starting with this prefix are not attached to a notice.
+      # @see https://github.com/airbrake/airbrake-ruby/issues/229
+      # @return [String]
+      IGNORE_PREFIX = '_'.freeze
+
+      def initialize
+        @weight = 110
+      end
+
+      # @macro call_filter
+      def call(notice)
+        th = Thread.current
+        thread_info = {}
+
+        if (vars = thread_variables(th)).any?
+          thread_info[:thread_variables] = vars
+        end
+
+        if (vars = fiber_variables(th)).any?
+          thread_info[:fiber_variables] = vars
+        end
+
+        # Present in Ruby 2.3+.
+        if th.respond_to?(:name) && (name = th.name)
+          thread_info[:name] = name
+        end
+
+        add_thread_info(th, thread_info)
+
+        notice[:params][:thread] = thread_info
+      end
+
+      private
+
+      def thread_variables(th)
+        th.thread_variables.map.with_object({}) do |var, h|
+          next if var.to_s.start_with?(IGNORE_PREFIX)
+          h[var] = sanitize_value(th.thread_variable_get(var))
+        end
+      end
+
+      def fiber_variables(th)
+        th.keys.map.with_object({}) do |key, h|
+          next if key.to_s.start_with?(IGNORE_PREFIX)
+          h[key] = sanitize_value(th[key])
+        end
+      end
+
+      def add_thread_info(th, thread_info)
+        thread_info[:self] = th.inspect
+        thread_info[:group] = th.group.list.map(&:inspect)
+        thread_info[:priority] = th.priority
+
+        thread_info[:safe_level] = th.safe_level unless Airbrake::JRUBY
+      end
+
+      def sanitize_value(value)
+        return value if SAFE_CLASSES.any? { |klass| value.is_a?(klass) }
+
+        case value
+        when Array
+          value = value.map { |elem| sanitize_value(elem) }
+        when Hash
+          Hash[value.map { |k, v| [k, sanitize_value(v)] }]
+        else
+          value.to_s
+        end
+      end
+    end
+  end
+end

data/lib/airbrake-ruby/hash_keyable.rb

@@ -0,0 +1,37 @@
+module Airbrake
+  # HashKeyable allows instances of the class to be used as a Hash key in a
+  # consistent manner.
+  #
+  # The class that includes it must implement *to_h*, which defines properties
+  # that all of the instances must share in order to produce the same {#hash}.
+  #
+  # @example
+  #   class C
+  #     include Airbrake::HashKeyable
+  #
+  #     def initialize(key)
+  #       @key = key
+  #     end
+  #
+  #     def to_h
+  #       { 'key' => @key }
+  #     end
+  #   end
+  #
+  #   h = {}
+  #   h[C.new('key1')] = 1
+  #   h[C.new('key1')] #=> 1
+  #   h[C.new('key2')] #=> nil
+  module HashKeyable
+    # @param [Object] other
+    # @return [Boolean]
+    def eql?(other)
+      other.is_a?(self.class) && other.hash == hash
+    end
+
+    # @return [Integer]
+    def hash
+      to_h.hash
+    end
+  end
+end

data/lib/airbrake-ruby/ignorable.rb

@@ -0,0 +1,44 @@
+module Airbrake
+  # Ignorable contains methods that allow the includee to be ignored.
+  #
+  # @example
+  #   class A
+  #     include Airbrake::Ignorable
+  #   end
+  #
+  #   a = A.new
+  #   a.ignore!
+  #   a.ignored? #=> true
+  #
+  # @since v3.2.0
+  # @api private
+  module Ignorable
+    attr_accessor :ignored
+
+    # Checks whether the instance was ignored.
+    # @return [Boolean]
+    # @see #ignore!
+    # rubocop:disable Style/DoubleNegation
+    def ignored?
+      !!ignored
+    end
+    # rubocop:enable Style/DoubleNegation
+
+    # Ignores an instance. Ignored instances must never reach the Airbrake
+    # dashboard.
+    # @return [void]
+    # @see #ignored?
+    def ignore!
+      self.ignored = true
+    end
+
+    private
+
+    # A method that is meant to be used as a guard.
+    # @raise [Airbrake::Error] when instance is ignored
+    def raise_if_ignored
+      return unless ignored?
+      raise Airbrake::Error, "cannot access ignored #{self.class}"
+    end
+  end
+end

data/lib/airbrake-ruby/nested_exception.rb

@@ -0,0 +1,39 @@
+module Airbrake
+  # A class that is capable of unwinding nested exceptions and representing them
+  # as JSON-like hash.
+  #
+  # @api private
+  # @since v1.0.4
+  class NestedException
+    # @return [Integer] the maximum number of nested exceptions that a notice
+    #   can unwrap. Exceptions that have a longer cause chain will be ignored
+    MAX_NESTED_EXCEPTIONS = 3
+
+    def initialize(config, exception)
+      @config = config
+      @exception = exception
+    end
+
+    def as_json
+      unwind_exceptions.map do |exception|
+        { type: exception.class.name,
+          message: exception.message,
+          backtrace: Backtrace.parse(@config, exception) }
+      end
+    end
+
+    private
+
+    def unwind_exceptions
+      exception_list = []
+      exception = @exception
+
+      while exception && exception_list.size < MAX_NESTED_EXCEPTIONS
+        exception_list << exception
+        exception = (exception.cause if exception.respond_to?(:cause))
+      end
+
+      exception_list
+    end
+  end
+end

data/lib/airbrake-ruby/notice.rb

@@ -0,0 +1,165 @@
+module Airbrake
+  # Represents a chunk of information that is meant to be either sent to
+  # Airbrake or ignored completely.
+  #
+  # @since v1.0.0
+  class Notice
+    # @return [Hash{Symbol=>String}] the information about the notifier library
+    NOTIFIER = {
+      name: 'airbrake-ruby'.freeze,
+      version: Airbrake::AIRBRAKE_RUBY_VERSION,
+      url: 'https://github.com/airbrake/airbrake-ruby'.freeze
+    }.freeze
+
+    # @return [Hash{Symbol=>String,Hash}] the information to be displayed in the
+    #   Context tab in the dashboard
+    CONTEXT = {
+      os: RUBY_PLATFORM,
+      language: "#{RUBY_ENGINE}/#{RUBY_VERSION}".freeze,
+      notifier: NOTIFIER
+    }.freeze
+
+    # @return [Integer] the maxium size of the JSON payload in bytes
+    MAX_NOTICE_SIZE = 64000
+
+    # @return [Integer] the maximum size of hashes, arrays and strings in the
+    #   notice.
+    PAYLOAD_MAX_SIZE = 10000
+
+    # @return [Array<StandardError>] the list of possible exceptions that might
+    #   be raised when an object is converted to JSON
+    JSON_EXCEPTIONS = [
+      IOError,
+      NotImplementedError,
+      JSON::GeneratorError,
+      Encoding::UndefinedConversionError
+    ].freeze
+
+    # @return [Array<Symbol>] the list of keys that can be be overwritten with
+    #   {Airbrake::Notice#[]=}
+    WRITABLE_KEYS = %i[notifier context environment session params].freeze
+
+    # @return [Array<Symbol>] parts of a Notice's payload that can be modified
+    #   by the truncator
+    TRUNCATABLE_KEYS = %i[errors environment session params].freeze
+
+    # @return [String] the name of the host machine
+    HOSTNAME = Socket.gethostname.freeze
+
+    # @return [String]
+    DEFAULT_SEVERITY = 'error'.freeze
+
+    include Ignorable
+
+    # @since v1.7.0
+    # @return [Hash{Symbol=>Object}] the hash with arbitrary objects to be used
+    #   in filters
+    attr_reader :stash
+
+    # @api private
+    def initialize(config, exception, params = {})
+      @config = config
+
+      @payload = {
+        errors: NestedException.new(config, exception).as_json,
+        context: context,
+        environment: {
+          program_name: $PROGRAM_NAME
+        },
+        session: {},
+        params: params
+      }
+      @stash = { exception: exception }
+      @truncator = Airbrake::Truncator.new(PAYLOAD_MAX_SIZE)
+    end
+
+    # Converts the notice to JSON. Calls +to_json+ on each object inside
+    # notice's payload. Truncates notices, JSON representation of which is
+    # bigger than {MAX_NOTICE_SIZE}.
+    #
+    # @return [Hash{String=>String}, nil]
+    # @api private
+    def to_json
+      loop do
+        begin
+          json = @payload.to_json
+        rescue *JSON_EXCEPTIONS => ex
+          @config.logger.debug("#{LOG_LABEL} `notice.to_json` failed: #{ex.class}: #{ex}")
+        else
+          return json if json && json.bytesize <= MAX_NOTICE_SIZE
+        end
+
+        break if truncate == 0
+      end
+    end
+
+    # Reads a value from notice's payload.
+    #
+    # @return [Object]
+    # @raise [Airbrake::Error] if the notice is ignored
+    def [](key)
+      raise_if_ignored
+      @payload[key]
+    end
+
+    # Writes a value to the payload hash. Restricts unrecognized writes.
+    #
+    # @example
+    #   notice[:params][:my_param] = 'foobar'
+    #
+    # @return [void]
+    # @raise [Airbrake::Error] if the notice is ignored
+    # @raise [Airbrake::Error] if the +key+ is not recognized
+    # @raise [Airbrake::Error] if the root value is not a Hash
+    def []=(key, value)
+      raise_if_ignored
+
+      unless WRITABLE_KEYS.include?(key)
+        raise Airbrake::Error,
+              ":#{key} is not recognized among #{WRITABLE_KEYS}"
+      end
+
+      unless value.respond_to?(:to_hash)
+        raise Airbrake::Error, "Got #{value.class} value, wanted a Hash"
+      end
+
+      @payload[key] = value.to_hash
+    end
+
+    private
+
+    def context
+      {
+        version: @config.app_version,
+        versions: @config.versions,
+        # We ensure that root_directory is always a String, so it can always be
+        # converted to JSON in a predictable manner (when it's a Pathname and in
+        # Rails environment, it converts to unexpected JSON).
+        rootDirectory: @config.root_directory.to_s,
+        environment: @config.environment,
+
+        # Make sure we always send hostname.
+        hostname: HOSTNAME,
+
+        severity: DEFAULT_SEVERITY
+      }.merge(CONTEXT).delete_if { |_key, val| val.nil? || val.empty? }
+    end
+
+    def truncate
+      TRUNCATABLE_KEYS.each do |key|
+        @payload[key] = @truncator.truncate(@payload[key])
+      end
+
+      new_max_size = @truncator.reduce_max_size
+      if new_max_size == 0
+        @config.logger.error(
+          "#{LOG_LABEL} truncation failed. File an issue at " \
+          "https://github.com/airbrake/airbrake-ruby " \
+          "and attach the following payload: #{@payload}"
+        )
+      end
+
+      new_max_size
+    end
+  end
+end

data/lib/airbrake-ruby/notice_notifier.rb

@@ -0,0 +1,228 @@
+module Airbrake
+  # NoticeNotifier is reponsible for sending notices to Airbrake. It supports
+  # synchronous and asynchronous delivery.
+  #
+  # @see Airbrake::Config The list of options
+  # @since v1.0.0
+  # @api public
+  # rubocop:disable Metrics/ClassLength
+  class NoticeNotifier
+    # @return [String] the label to be prepended to the log output
+    LOG_LABEL = '**Airbrake:'.freeze
+
+    # @return [String] inspect output template
+    INSPECT_TEMPLATE =
+      "#<#{self}:0x%<id>s project_id=\"%<project_id>s\" " \
+      "project_key=\"%<project_key>s\" " \
+      "host=\"%<host>s\" filter_chain=%<filter_chain>s>".freeze
+
+    # @return [Array<Class>] filters to be executed first
+    DEFAULT_FILTERS = [
+      Airbrake::Filters::SystemExitFilter,
+      Airbrake::Filters::GemRootFilter
+
+      # Optional filters (must be included by users):
+      # Airbrake::Filters::ThreadFilter
+    ].freeze
+
+    # Creates a new notice notifier with the given config options.
+    #
+    # @example
+    #   config = Airbrake::Config.new
+    #   config.project_id = 123
+    #   config.project_key = '321'
+    #   notice_notifier = Airbrake::NoticeNotifier.new(config)
+    #
+    # @param [Airbrake::Config] config
+    def initialize(config, perf_notifier = nil)
+      @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
+
+      @context = {}
+      @filter_chain = FilterChain.new
+      @async_sender = AsyncSender.new(@config)
+      @sync_sender = SyncSender.new(@config)
+      @perf_notifier = perf_notifier
+
+      add_default_filters
+    end
+
+    # @macro see_public_api_method
+    def notify(exception, params = {}, &block)
+      send_notice(exception, params, default_sender, &block)
+    end
+
+    # @macro see_public_api_method
+    def notify_sync(exception, params = {}, &block)
+      send_notice(exception, params, @sync_sender, &block).value
+    end
+
+    # @deprecated Update the airbrake gem to v8.1.0 or higher
+    def notify_request(request_info, promise = Promise.new)
+      @config.logger.info(
+        "#{LOG_LABEL} #{self.class}##{__method__} is deprecated. Update " \
+        'the airbrake gem to v8.1.0 or higher'
+      )
+      @perf_notifier.notify(Request.new(request_info), promise)
+    end
+
+    # @macro see_public_api_method
+    def add_filter(filter = nil, &block)
+      @filter_chain.add_filter(block_given? ? block : filter)
+    end
+
+    # @macro see_public_api_method
+    def delete_filter(filter_class)
+      @filter_chain.delete_filter(filter_class)
+    end
+
+    # @macro see_public_api_method
+    def build_notice(exception, params = {})
+      if @async_sender.closed?
+        raise Airbrake::Error,
+              "attempted to build #{exception} with closed Airbrake instance"
+      end
+
+      if exception.is_a?(Airbrake::Notice)
+        exception[:params].merge!(params)
+        exception
+      else
+        Notice.new(@config, convert_to_exception(exception), params.dup)
+      end
+    end
+
+    # @macro see_public_api_method
+    def close
+      @async_sender.close
+    end
+
+    # @macro see_public_api_method
+    def configured?
+      @config.valid?
+    end
+
+    # @macro see_public_api_method
+    def merge_context(context)
+      @context.merge!(context)
+    end
+
+    # @return [String] customized inspect to lessen the amount of clutter
+    def inspect
+      format(
+        INSPECT_TEMPLATE,
+        id: (object_id << 1).to_s(16).rjust(16, '0'),
+        project_id: @config.project_id,
+        project_key: @config.project_key,
+        host: @config.host,
+        filter_chain: @filter_chain.inspect
+      )
+    end
+
+    # @return [String] {#inspect} for PrettyPrint
+    def pretty_print(q)
+      q.text("#<#{self.class}:0x#{(object_id << 1).to_s(16).rjust(16, '0')} ")
+      q.text(
+        "project_id=\"#{@config.project_id}\" project_key=\"#{@config.project_key}\" " \
+        "host=\"#{@config.host}\" filter_chain="
+      )
+      q.pp(@filter_chain)
+      q.text('>')
+    end
+
+    private
+
+    def convert_to_exception(ex)
+      if ex.is_a?(Exception) || Backtrace.java_exception?(ex)
+        # Manually created exceptions don't have backtraces, so we create a fake
+        # one, whose first frame points to the place where Airbrake was called
+        # (normally via `notify`).
+        ex.set_backtrace(clean_backtrace) unless ex.backtrace
+        return ex
+      end
+
+      e = RuntimeError.new(ex.to_s)
+      e.set_backtrace(clean_backtrace)
+      e
+    end
+
+    def send_notice(exception, params, sender)
+      promise = Airbrake::Promise.new
+      if @config.ignored_environment?
+        return promise.reject("The '#{@config.environment}' environment is ignored")
+      end
+
+      notice = build_notice(exception, params)
+      yield notice if block_given?
+      @filter_chain.refine(notice)
+
+      return promise.reject("#{notice} was marked as ignored") if notice.ignored?
+
+      sender.send(notice, promise)
+    end
+
+    def default_sender
+      return @async_sender if @async_sender.has_workers?
+
+      @config.logger.warn(
+        "#{LOG_LABEL} falling back to sync delivery because there are no " \
+        "running async workers"
+      )
+      @sync_sender
+    end
+
+    def clean_backtrace
+      caller_copy = Kernel.caller
+      clean_bt = caller_copy.drop_while { |frame| frame.include?('/lib/airbrake') }
+
+      # If true, then it's likely an internal library error. In this case return
+      # at least some backtrace to simplify debugging.
+      return caller_copy if clean_bt.empty?
+      clean_bt
+    end
+
+    # rubocop:disable Metrics/AbcSize
+    def add_default_filters
+      DEFAULT_FILTERS.each { |f| add_filter(f.new) }
+
+      if (whitelist_keys = @config.whitelist_keys).any?
+        add_filter(
+          Airbrake::Filters::KeysWhitelist.new(@config.logger, whitelist_keys)
+        )
+      end
+
+      if (blacklist_keys = @config.blacklist_keys).any?
+        add_filter(
+          Airbrake::Filters::KeysBlacklist.new(@config.logger, blacklist_keys)
+        )
+      end
+
+      add_filter(Airbrake::Filters::ContextFilter.new(@context))
+      add_filter(Airbrake::Filters::ExceptionAttributesFilter.new(@config.logger))
+
+      return unless (root_directory = @config.root_directory)
+      [
+        Airbrake::Filters::RootDirectoryFilter,
+        Airbrake::Filters::GitRevisionFilter,
+        Airbrake::Filters::GitRepositoryFilter
+      ].each do |filter|
+        add_filter(filter.new(root_directory))
+      end
+
+      add_filter(
+        Airbrake::Filters::GitLastCheckoutFilter.new(@config.logger, root_directory)
+      )
+    end
+    # rubocop:enable Metrics/AbcSize
+  end
+  # rubocop:enable Metrics/ClassLength
+end