airbrake-ruby 4.6.0

data/lib/airbrake-ruby/async_sender.rb

@@ -0,0 +1,142 @@
+module Airbrake
+  # Responsible for sending notices to Airbrake asynchronously. The class
+  # supports an unlimited number of worker threads and an unlimited queue size
+  # (both values are configurable).
+  #
+  # @see SyncSender
+  # @api private
+  # @since v1.0.0
+  class AsyncSender
+    include Loggable
+
+    # @return [String]
+    WILL_NOT_DELIVER_MSG =
+      "%<log_label>s AsyncSender has reached its capacity of %<capacity>s " \
+      "and the following notice will not be delivered " \
+      "Error: %<type>s - %<message>s\nBacktrace: %<backtrace>s\n".freeze
+
+    # @return [ThreadGroup] the list of workers
+    # @note This is exposed for eaiser unit testing
+    # @since v4.0.0
+    attr_reader :workers
+
+    # @return [Array<[Airbrake::Notice,Airbrake::Promise]>] the list of unsent
+    #   payload
+    # @note This is exposed for eaiser unit testing
+    # @since v4.0.0
+    attr_reader :unsent
+
+    def initialize
+      @config = Airbrake::Config.instance
+      @unsent = SizedQueue.new(Airbrake::Config.instance.queue_size)
+      @sender = SyncSender.new
+      @closed = false
+      @workers = ThreadGroup.new
+      @mutex = Mutex.new
+      @pid = nil
+    end
+
+    # Asynchronously sends a notice to Airbrake.
+    #
+    # @param [Airbrake::Notice] notice A notice that was generated by the
+    #   library
+    # @return [Airbrake::Promise]
+    def send(notice, promise)
+      return will_not_deliver(notice, promise) if @unsent.size >= @unsent.max
+
+      @unsent << [notice, promise]
+      promise
+    end
+
+    # Closes the instance making it a no-op (it shut downs all worker
+    # threads). Before closing, waits on all unsent notices to be sent.
+    #
+    # @return [void]
+    # @raise [Airbrake::Error] when invoked more than one time
+    def close
+      threads = @mutex.synchronize do
+        raise Airbrake::Error, 'attempted to close already closed sender' if closed?
+
+        unless @unsent.empty?
+          msg = "#{LOG_LABEL} waiting to send #{@unsent.size} unsent notice(s)..."
+          logger.debug(msg + ' (Ctrl-C to abort)')
+        end
+
+        @config.workers.times { @unsent << [:stop, Airbrake::Promise.new] }
+        @closed = true
+        @workers.list.dup
+      end
+
+      threads.each(&:join)
+      logger.debug("#{LOG_LABEL} closed")
+    end
+
+    # Checks whether the sender is closed and thus usable.
+    # @return [Boolean]
+    def closed?
+      @closed
+    end
+
+    # Checks if an active sender has any workers. A sender doesn't have any
+    # workers only in two cases: when it was closed or when all workers
+    # crashed. An *active* sender doesn't have any workers only when something
+    # went wrong.
+    #
+    # Workers are expected to crash when you +fork+ the process the workers are
+    # living in. In this case we detect a +fork+ and try to revive them here.
+    #
+    # Another possible scenario that crashes workers is when you close the
+    # instance on +at_exit+, but some other +at_exit+ hook prevents the process
+    # from exiting.
+    #
+    # @return [Boolean] true if an instance wasn't closed, but has no workers
+    # @see https://goo.gl/oydz8h Example of at_exit that prevents exit
+    def has_workers?
+      @mutex.synchronize do
+        return false if @closed
+
+        if @pid != Process.pid && @workers.list.empty?
+          @pid = Process.pid
+          spawn_workers
+        end
+
+        !@closed && @workers.list.any?
+      end
+    end
+
+    private
+
+    def spawn_workers
+      @workers = ThreadGroup.new
+      @config.workers.times { @workers.add(spawn_worker) }
+      @workers.enclose
+    end
+
+    def spawn_worker
+      Thread.new do
+        while (message = @unsent.pop)
+          break if message.first == :stop
+          @sender.send(*message)
+        end
+      end
+    end
+
+    def will_not_deliver(notice, promise)
+      error = notice[:errors].first
+
+      logger.error(
+        format(
+          WILL_NOT_DELIVER_MSG,
+          log_label: LOG_LABEL,
+          capacity: @unsent.max,
+          type: error[:type],
+          message: error[:message],
+          backtrace: error[:backtrace].map do |line|
+            "#{line[:file]}:#{line[:line]} in `#{line[:function]}'"
+          end.join("\n")
+        )
+      )
+      promise.reject("AsyncSender has reached its capacity of #{@unsent.max}")
+    end
+  end
+end

data/lib/airbrake-ruby/backtrace.rb

@@ -0,0 +1,196 @@
+module Airbrake
+  # Represents a cross-Ruby backtrace from exceptions (including JRuby Java
+  # exceptions). Provides information about stack frames (such as line number,
+  # file and method) in convenient for Airbrake format.
+  #
+  # @example
+  #   begin
+  #     raise 'Oops!'
+  #   rescue
+  #     Backtrace.parse($!)
+  #   end
+  #
+  # @api private
+  # @since v1.0.0
+  module Backtrace
+    module Patterns
+      # @return [Regexp] the pattern that matches standard Ruby stack frames,
+      #   such as ./spec/notice_spec.rb:43:in `block (3 levels) in <top (required)>'
+      RUBY = %r{\A
+        (?<file>.+)       # Matches './spec/notice_spec.rb'
+        :
+        (?<line>\d+)      # Matches '43'
+        :in\s
+        `(?<function>.*)' # Matches "`block (3 levels) in <top (required)>'"
+      \z}x
+
+      # @return [Regexp] the pattern that matches JRuby Java stack frames, such
+      #  as org.jruby.ast.NewlineNode.interpret(NewlineNode.java:105)
+      JAVA = %r{\A
+        (?<function>.+)  # Matches 'org.jruby.ast.NewlineNode.interpret'
+        \(
+          (?<file>
+            (?:uri:classloader:/.+(?=:)) # Matches '/META-INF/jruby.home/protocol.rb'
+            |
+            (?:uri_3a_classloader_3a_.+(?=:)) # Matches 'uri_3a_classloader_3a_/gems/...'
+            |
+            [^:]+        # Matches 'NewlineNode.java'
+          )
+          :?
+          (?<line>\d+)?  # Matches '105'
+        \)
+      \z}x
+
+      # @return [Regexp] the pattern that tries to assume what a generic stack
+      #   frame might look like, when exception's backtrace is set manually.
+      GENERIC = %r{\A
+        (?:from\s)?
+        (?<file>.+)              # Matches '/foo/bar/baz.ext'
+        :
+        (?<line>\d+)?            # Matches '43' or nothing
+        (?:
+          in\s`(?<function>.+)'  # Matches "in `func'"
+        |
+          :in\s(?<function>.+)   # Matches ":in func"
+        )?                       # ... or nothing
+      \z}x
+
+      # @return [Regexp] the pattern that matches exceptions from PL/SQL such as
+      #   ORA-06512: at "STORE.LI_LICENSES_PACK", line 1945
+      # @note This is raised by https://github.com/kubo/ruby-oci8
+      OCI = /\A
+        (?:
+          ORA-\d{5}
+          :\sat\s
+          (?:"(?<function>.+)",\s)?
+          line\s(?<line>\d+)
+        |
+          #{GENERIC}
+        )
+      \z/x
+
+      # @return [Regexp] the pattern that matches CoffeeScript backtraces
+      #   usually coming from Rails & ExecJS
+      EXECJS = /\A
+        (?:
+          # Matches 'compile ((execjs):6692:19)'
+          (?<function>.+)\s\((?<file>.+):(?<line>\d+):\d+\)
+        |
+          # Matches 'bootstrap_node.js:467:3'
+          (?<file>.+):(?<line>\d+):\d+(?<function>)
+        |
+          # Matches the Ruby part of the backtrace
+          #{RUBY}
+        )
+      \z/x
+    end
+
+    # @return [Integer] how many first frames should include code hunks
+    CODE_FRAME_LIMIT = 10
+
+    # Parses an exception's backtrace.
+    #
+    # @param [Exception] exception The exception, which contains a backtrace to
+    #   parse
+    # @return [Array<Hash{Symbol=>String,Integer}>] the parsed backtrace
+    def self.parse(exception)
+      return [] if exception.backtrace.nil? || exception.backtrace.none?
+      parse_backtrace(exception)
+    end
+
+    # Checks whether the given exception was generated by JRuby's VM.
+    #
+    # @param [Exception] exception
+    # @return [Boolean]
+    def self.java_exception?(exception)
+      if defined?(Java::JavaLang::Throwable) &&
+         exception.is_a?(Java::JavaLang::Throwable)
+        return true
+      end
+
+      return false unless exception.respond_to?(:backtrace)
+
+      (Patterns::JAVA =~ exception.backtrace.first) != nil
+    end
+
+    class << self
+      include Loggable
+
+      private
+
+      def best_regexp_for(exception)
+        if java_exception?(exception)
+          Patterns::JAVA
+        elsif oci_exception?(exception)
+          Patterns::OCI
+        elsif execjs_exception?(exception)
+          Patterns::EXECJS
+        else
+          Patterns::RUBY
+        end
+      end
+
+      def oci_exception?(exception)
+        defined?(OCIError) && exception.is_a?(OCIError)
+      end
+
+      def execjs_exception?(exception)
+        return false unless defined?(ExecJS::RuntimeError)
+        return true if exception.is_a?(ExecJS::RuntimeError)
+        return true if exception.cause && exception.cause.is_a?(ExecJS::RuntimeError)
+
+        false
+      end
+
+      def stack_frame(regexp, stackframe)
+        if (match = match_frame(regexp, stackframe))
+          return {
+            file: match[:file],
+            line: (Integer(match[:line]) if match[:line]),
+            function: match[:function]
+          }
+        end
+
+        logger.error(
+          "can't parse '#{stackframe}' (please file an issue so we can fix " \
+          "it: https://github.com/airbrake/airbrake-ruby/issues/new)"
+        )
+        { file: nil, line: nil, function: stackframe }
+      end
+
+      def match_frame(regexp, stackframe)
+        match = regexp.match(stackframe)
+        return match if match
+
+        Patterns::GENERIC.match(stackframe)
+      end
+
+      def parse_backtrace(exception)
+        regexp = best_regexp_for(exception)
+        root_directory = Airbrake::Config.instance.root_directory.to_s
+
+        exception.backtrace.map.with_index do |stackframe, i|
+          frame = stack_frame(regexp, stackframe)
+          next(frame) if !Airbrake::Config.instance.code_hunks || frame[:file].nil?
+
+          if !root_directory.empty?
+            populate_code(frame) if frame_in_root?(frame, root_directory)
+          elsif i < CODE_FRAME_LIMIT
+            populate_code(frame)
+          end
+
+          frame
+        end
+      end
+
+      def populate_code(frame)
+        code = Airbrake::CodeHunk.new.get(frame[:file], frame[:line])
+        frame[:code] = code if code
+      end
+
+      def frame_in_root?(frame, root_directory)
+        frame[:file].start_with?(root_directory) && frame[:file] !~ %r{vendor/bundle}
+      end
+    end
+  end
+end

data/lib/airbrake-ruby/benchmark.rb

@@ -0,0 +1,39 @@
+module Airbrake
+  # Benchmark benchmarks Ruby code.
+  #
+  # @since v4.2.4
+  # @api private
+  class Benchmark
+    # Measures monotonic time for the given operation.
+    #
+    # @yieldreturn [void]
+    def self.measure
+      benchmark = new
+
+      yield
+
+      benchmark.stop
+      benchmark.duration
+    end
+
+    # @return [Float]
+    attr_reader :duration
+
+    # @since v4.3.0
+    def initialize
+      @start = MonotonicTime.time_in_ms
+      @duration = 0.0
+    end
+
+    # Stops the benchmark and stores `duration`.
+    #
+    # @since v4.3.0
+    # @return [Boolean] true for the first invocation, false in all other cases
+    def stop
+      return false if @duration > 0.0
+
+      @duration = MonotonicTime.time_in_ms - @start
+      true
+    end
+  end
+end

data/lib/airbrake-ruby/code_hunk.rb

@@ -0,0 +1,51 @@
+module Airbrake
+  # Represents a small hunk of code consisting of a base line and a couple lines
+  # around it
+  # @api private
+  class CodeHunk
+    # @return [Integer] the maximum length of a line
+    MAX_LINE_LEN = 200
+
+    # @return [Integer] how many lines should be read around the base line
+    NLINES = 2
+
+    include Loggable
+
+    # @param [String] file The file to read
+    # @param [Integer] line The base line in the file
+    # @return [Hash{Integer=>String}, nil] lines of code around the base line
+    def get(file, line)
+      return unless File.exist?(file)
+      return unless line
+
+      lines = get_lines(file, [line - NLINES, 1].max, line + NLINES) || {}
+      return { 1 => '' } if lines.empty?
+
+      lines
+    end
+
+    private
+
+    def get_from_cache(file)
+      Airbrake::FileCache[file] ||= File.foreach(file)
+    rescue StandardError => ex
+      logger.error(
+        "#{self.class.name}: can't read code hunk for #{file}: #{ex}"
+      )
+      nil
+    end
+
+    def get_lines(file, start_line, end_line)
+      return unless (cached_file = get_from_cache(file))
+
+      lines = {}
+      cached_file.with_index(1) do |l, i|
+        next if i < start_line
+        break if i > end_line
+
+        lines[i] = l[0...MAX_LINE_LEN].rstrip
+      end
+      lines
+    end
+  end
+end

data/lib/airbrake-ruby/config.rb

@@ -0,0 +1,229 @@
+module Airbrake
+  # Represents the Airbrake config. A config contains all the options that you
+  # can use to configure an Airbrake instance.
+  #
+  # @api public
+  # @since v1.0.0
+  class Config
+    # @return [Integer] the project identificator. This value *must* be set.
+    # @api public
+    attr_accessor :project_id
+
+    # @return [String] the project key. This value *must* be set.
+    # @api public
+    attr_accessor :project_key
+
+    # @return [Hash] the proxy parameters such as (:host, :port, :user and
+    #   :password)
+    # @api public
+    attr_accessor :proxy
+
+    # @return [Logger] the default logger used for debug output
+    # @api public
+    attr_reader :logger
+
+    # @return [String] the version of the user's application
+    # @api public
+    attr_accessor :app_version
+
+    # @return [Hash{String=>String}] arbitrary versions that your app wants to
+    #   track
+    # @api public
+    # @since v2.10.0
+    attr_accessor :versions
+
+    # @return [Integer] the max number of notices that can be queued up
+    # @api public
+    attr_accessor :queue_size
+
+    # @return [Integer] the number of worker threads that process the notice
+    #   queue
+    # @api public
+    attr_accessor :workers
+
+    # @return [String] the host, which provides the API endpoint to which
+    #   exceptions should be sent
+    # @api public
+    attr_accessor :host
+
+    # @return [String, Pathname] the working directory of your project
+    # @api public
+    attr_accessor :root_directory
+
+    # @return [String, Symbol] the environment the application is running in
+    # @api public
+    attr_accessor :environment
+
+    # @return [Array<String,Symbol,Regexp>] the array of environments that
+    #   forbids sending exceptions when the application is running in them.
+    #   Other possible environments not listed in the array will allow sending
+    #   occurring exceptions.
+    # @api public
+    attr_accessor :ignore_environments
+
+    # @return [Integer] The HTTP timeout in seconds.
+    # @api public
+    attr_accessor :timeout
+
+    # @return [Array<String, Symbol, Regexp>] the keys, which should be
+    #   filtered
+    # @api public
+    # @since v1.2.0
+    attr_accessor :blacklist_keys
+
+    # @return [Array<String, Symbol, Regexp>] the keys, which shouldn't be
+    #   filtered
+    # @api public
+    # @since v1.2.0
+    attr_accessor :whitelist_keys
+
+    # @return [Boolean] true if the library should attach code hunks to each
+    #   frame in a backtrace, false otherwise
+    # @api public
+    # @since v2.5.0
+    attr_accessor :code_hunks
+
+    # @return [Boolean] true if the library should send route performance stats
+    #   to Airbrake, false otherwise
+    # @api public
+    # @since v3.2.0
+    attr_accessor :performance_stats
+
+    # @return [Integer] how many seconds to wait before sending collected route
+    #   stats
+    # @api private
+    # @since v3.2.0
+    attr_accessor :performance_stats_flush_period
+
+    # @return [Boolean] true if the library should send SQL stats to Airbrake,
+    #   false otherwise
+    # @api public
+    # @since v4.6.0
+    attr_accessor :query_stats
+
+    class << self
+      # @return [Config]
+      attr_writer :instance
+
+      # @return [Config]
+      def instance
+        @instance ||= new
+      end
+    end
+
+    # @param [Hash{Symbol=>Object}] user_config the hash to be used to build the
+    #   config
+    def initialize(user_config = {})
+      self.proxy = {}
+      self.queue_size = 100
+      self.workers = 1
+      self.code_hunks = true
+      self.logger = ::Logger.new(File::NULL)
+      self.project_id = user_config[:project_id]
+      self.project_key = user_config[:project_key]
+      self.host = 'https://api.airbrake.io'
+
+      self.ignore_environments = []
+
+      self.timeout = user_config[:timeout]
+
+      self.blacklist_keys = []
+      self.whitelist_keys = []
+
+      self.root_directory = File.realpath(
+        (defined?(Bundler) && Bundler.root) ||
+        Dir.pwd
+      )
+
+      self.versions = {}
+      self.performance_stats = true
+      self.performance_stats_flush_period = 15
+      self.query_stats = false
+
+      merge(user_config)
+    end
+
+    # The full URL to the Airbrake Notice API. Based on the +:host+ option.
+    # @return [URI] the endpoint address
+    def endpoint
+      @endpoint ||=
+        begin
+          self.host = ('https://' << host) if host !~ %r{\Ahttps?://}
+          api = "api/v3/projects/#{project_id}/notices"
+          URI.join(host, api)
+        end
+    end
+
+    # Sets the logger. Never allows to assign `nil` as the logger.
+    # @return [Logger] the logger
+    def logger=(logger)
+      @logger = logger || @logger
+    end
+
+    # Merges the given +config_hash+ with itself.
+    #
+    # @example
+    #   config.merge(host: 'localhost:8080')
+    #
+    # @return [self] the merged config
+    def merge(config_hash)
+      config_hash.each_pair { |option, value| set_option(option, value) }
+      self
+    end
+
+    # @return [Boolean] true if the config meets the requirements, false
+    #   otherwise
+    def valid?
+      validate.resolved?
+    end
+
+    # @return [Promise]
+    # @see Validator.validate
+    def validate
+      Validator.validate(self)
+    end
+
+    # @return [Promise]
+    # @see Validator.check_notify_ability
+    def check_notify_ability
+      Validator.check_notify_ability(self)
+    end
+
+    # @return [Boolean] true if the config ignores current environment, false
+    #   otherwise
+    def ignored_environment?
+      check_notify_ability.rejected?
+    end
+
+    # @return [Promise] resolved promise if config is valid & can notify,
+    #   rejected otherwise
+    def check_configuration
+      promise = validate
+      return promise if promise.rejected?
+
+      check_notify_ability
+    end
+
+    # @return [Promise] resolved promise if neither of the performance options
+    #   reject it, false otherwise
+    def check_performance_options(resource)
+      promise = Airbrake::Promise.new
+
+      if !performance_stats
+        promise.reject("The Performance Stats feature is disabled")
+      elsif resource.is_a?(Airbrake::Query) && !query_stats
+        promise.reject("The Query Stats feature is disabled")
+      else
+        promise
+      end
+    end
+
+    private
+
+    def set_option(option, value)
+      __send__("#{option}=", value)
+    rescue NoMethodError
+      raise Airbrake::Error, "unknown option '#{option}'"
+    end
+  end
+end