airbrake-ruby 4.6.0

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/inspectable.rb

@@ -0,0 +1,39 @@
+module Airbrake
+  # Inspectable provides custom inspect methods that reduce clutter printed in
+  # REPLs for notifier objects. These custom methods display only essential
+  # information such as project id/key and filters.
+  #
+  # @since v3.2.6
+  # @api private
+  module Inspectable
+    # @return [String] inspect output template
+    INSPECT_TEMPLATE =
+      "#<%<classname>s:0x%<id>s project_id=\"%<project_id>s\" " \
+      "project_key=\"%<project_key>s\" " \
+      "host=\"%<host>s\" filter_chain=%<filter_chain>s>".freeze
+
+    # @return [String] customized inspect to lessen the amount of clutter
+    def inspect
+      format(
+        INSPECT_TEMPLATE,
+        classname: self.class.name,
+        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
+  end
+end

data/lib/airbrake-ruby/loggable.rb

@@ -0,0 +1,34 @@
+module Airbrake
+  # Loggable is included into any class that wants to be able to log.
+  #
+  # By default, Loggable defines a null logger that doesn't do anything. You are
+  # supposed to overwrite it via the {instance} method before calling {logger}.
+  #
+  # @example
+  #   class A
+  #     include Loggable
+  #
+  #     def initialize
+  #       logger.debug('Initialized A')
+  #     end
+  #   end
+  #
+  # @since v4.0.0
+  # @api private
+  module Loggable
+    class << self
+      # @return [Logger]
+      attr_writer :instance
+
+      # @return [Logger]
+      def instance
+        @instance ||= ::Logger.new(File::NULL)
+      end
+    end
+
+    # @return [Logger] standard Ruby logger object
+    def logger
+      Loggable.instance
+    end
+  end
+end

data/lib/airbrake-ruby/monotonic_time.rb

@@ -0,0 +1,43 @@
+module Airbrake
+  # MonotonicTime is a helper for getting monotonic time suitable for
+  # performance measurements. It guarantees that the time is strictly linearly
+  # increasing (unlike realtime).
+  #
+  # @example
+  #   MonotonicTime.time_in_ms #=> 287138801.144576
+  #
+  # @see http://pubs.opengroup.org/onlinepubs/9699919799/functions/clock_getres.html
+  # @since v4.2.4
+  # @api private
+  module MonotonicTime
+    class << self
+      # @return [Integer] current monotonic time in milliseconds
+      def time_in_ms
+        time_in_nanoseconds / (10.0**6)
+      end
+
+      private
+
+      if defined?(Process::CLOCK_MONOTONIC)
+
+        def time_in_nanoseconds
+          Process.clock_gettime(Process::CLOCK_MONOTONIC, :nanosecond)
+        end
+
+      elsif RUBY_ENGINE == 'jruby'
+
+        def time_in_nanoseconds
+          java.lang.System.nanoTime
+        end
+
+      else
+
+        def time_in_nanoseconds
+          time = Time.now
+          time.to_i * (10**9) + time.nsec
+        end
+
+      end
+    end
+  end
+end

data/lib/airbrake-ruby/nested_exception.rb

@@ -0,0 +1,38 @@
+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(exception)
+      @exception = exception
+    end
+
+    def as_json
+      unwind_exceptions.map do |exception|
+        { type: exception.class.name,
+          message: exception.message,
+          backtrace: Backtrace.parse(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,162 @@
+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
+    include Loggable
+    include Stashable
+
+    # @api private
+    def initialize(exception, params = {})
+      @config = Airbrake::Config.instance
+      @payload = {
+        errors: NestedException.new(exception).as_json,
+        context: context,
+        environment: {
+          program_name: $PROGRAM_NAME
+        },
+        session: {},
+        params: params
+      }
+      @truncator = Airbrake::Truncator.new(PAYLOAD_MAX_SIZE)
+
+      stash[:exception] = exception
+    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
+          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
+        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