airbrake-ruby 4.6.0 → 6.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: cf81123734caec939f2b487e0ca743ea26659f46
-  data.tar.gz: ba8e315a20b3f59d0863d027010e54311ba15d9d
+SHA256:
+  metadata.gz: 0c1f0e8b950ee1f9b9e6270071d3513508fd2c342673d206a50951ecca0281e0
+  data.tar.gz: 31fb69c96a4aede059904726542f925df9066365f864765254896d89c67a7e30
 SHA512:
-  metadata.gz: 551704a67996c2064820507d4fb3dd0218df863e7433d77356dd45bc62ecab112508372125a98c8d2f651c2693716e96c86b8e0172ffd265b60de0258d1b7acf
-  data.tar.gz: c32da13a83d385bc91b7cc2f236324ae29918005bac9450076d03fc0b707f49b2474049dac7c13fb78f1b0c848c2a1e95579f3c5f1c2315581c8db7d8c1eb3e0
+  metadata.gz: e6f2d8369dbc2b58b257ab7e06e2abf1f893b90570eb1ec2012e2ecd35f98f6b03b44130605a689dc57f3367400b220821a511428bdd3dfa4841c2955a0ff9af
+  data.tar.gz: 217107fd6982ccea8b0f4158546688d78d6d2415b627f908016de3f036c4cbc1ccae6c2148b670c4eee5fc93a45f8fdf62d37431a492cc0f20d3ca662a8ae5de

data/lib/airbrake-ruby/async_sender.rb

@@ -1,142 +1,57 @@
 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).
+  # Responsible for sending notices to Airbrake asynchronously.
   #
   # @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
+    def initialize(method = :post, name = 'async-sender')
       @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
+      @sync_sender = SyncSender.new(method)
+      @name = name
     end
 
     # Asynchronously sends a notice to Airbrake.
     #
-    # @param [Airbrake::Notice] notice A notice that was generated by the
-    #   library
+    # @param [Airbrake::Notice] data Whatever needs to be sent
+    # @param [Airbrake::Promise] promise
+    # @param [URI] endpoint Where to send +data+
     # @return [Airbrake::Promise]
-    def send(notice, promise)
-      return will_not_deliver(notice, promise) if @unsent.size >= @unsent.max
+    def send(data, promise, endpoint = @config.error_endpoint)
+      unless thread_pool << [data, promise, endpoint]
+        return promise.reject(
+          "AsyncSender has reached its capacity of #{@config.queue_size}",
+        )
+      end
 
-      @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")
+      @sync_sender.close
+      thread_pool.close
     end
 
-    # Checks whether the sender is closed and thus usable.
     # @return [Boolean]
     def closed?
-      @closed
+      thread_pool.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
+    # @return [Boolean]
     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
+      thread_pool.has_workers?
     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")
-        )
+    def thread_pool
+      @thread_pool ||= ThreadPool.new(
+        name: @name,
+        worker_size: @config.workers,
+        queue_size: @config.queue_size,
+        block: proc { |args| @sync_sender.send(*args) },
       )
-      promise.reject("AsyncSender has reached its capacity of #{@unsent.max}")
     end
   end
 end

data/lib/airbrake-ruby/backlog.rb

@@ -0,0 +1,123 @@
+module Airbrake
+  # Backlog accepts notices and APM events and synchronously sends them in the
+  # background at regular intervals. The backlog is a queue of data that failed
+  # to be sent due to some error. In a nutshell, it's a retry mechanism.
+  #
+  # @api private
+  # @since v6.2.0
+  class Backlog
+    include Loggable
+
+    # @return [Integer] how many records to keep in the backlog
+    BACKLOG_SIZE = 100
+
+    # @return [Integer] flush period in seconds
+    TWO_MINUTES = 60 * 2
+
+    def initialize(sync_sender, flush_period = TWO_MINUTES)
+      @sync_sender = sync_sender
+      @flush_period = flush_period
+      @queue = SizedQueue.new(BACKLOG_SIZE).extend(MonitorMixin)
+      @has_backlog_data = @queue.new_cond
+      @schedule_flush = nil
+
+      @seen = Set.new
+    end
+
+    # Appends data to the backlog. Once appended, the flush schedule will
+    # start. Chainable.
+    #
+    # @example
+    #   backlog << [{ 'data' => 1 }, 'https://airbrake.io/api']
+    #
+    # @param [Array<#to_json, String>] data An array of two elements, where the
+    #   first element is the data we are sending and the second element is the
+    #   URL that we are sending to
+    # @return [self]
+    def <<(data)
+      @queue.synchronize do
+        return self if @seen.include?(data)
+
+        @seen << data
+
+        begin
+          @queue.push(data, true)
+        rescue ThreadError
+          logger.error("#{LOG_LABEL} Airbrake::Backlog full")
+          return self
+        end
+
+        @has_backlog_data.signal
+        schedule_flush
+
+        self
+      end
+    end
+
+    # Closes all the resources that this sender has allocated.
+    #
+    # @return [void]
+    # @since v6.2.0
+    def close
+      @queue.synchronize do
+        if @schedule_flush
+          @schedule_flush.kill
+          logger.debug("#{LOG_LABEL} Airbrake::Backlog closed")
+        end
+      end
+    end
+
+    private
+
+    def schedule_flush
+      @schedule_flush ||= Thread.new do
+        loop do
+          @queue.synchronize do
+            wait
+            next if @queue.empty?
+
+            flush
+          end
+        end
+      end
+    end
+
+    def wait
+      @has_backlog_data.wait(@flush_period) while time_elapsed < @flush_period
+      @last_flush = nil
+    end
+
+    def time_elapsed
+      MonotonicTime.time_in_s - last_flush
+    end
+
+    def last_flush
+      @last_flush ||= MonotonicTime.time_in_s
+    end
+
+    def flush
+      unless @queue.empty?
+        logger.debug(
+          "#{LOG_LABEL} Airbrake::Backlog flushing #{@queue.size} messages",
+        )
+      end
+
+      failed = 0
+
+      until @queue.empty?
+        data, endpoint = @queue.pop
+        promise = Airbrake::Promise.new
+        @sync_sender.send(data, promise, endpoint)
+        failed += 1 if promise.rejected?
+      end
+
+      if failed > 0
+        logger.debug(
+          "#{LOG_LABEL} Airbrake::Backlog #{failed} messages were not flushed",
+        )
+      end
+
+      @seen.clear
+    end
+  end
+end

data/lib/airbrake-ruby/backtrace.rb

@@ -22,7 +22,7 @@ module Airbrake
         (?<line>\d+)      # Matches '43'
         :in\s
         `(?<function>.*)' # Matches "`block (3 levels) in <top (required)>'"
-      \z}x
+      \z}x.freeze
 
       # @return [Regexp] the pattern that matches JRuby Java stack frames, such
       #  as org.jruby.ast.NewlineNode.interpret(NewlineNode.java:105)
@@ -39,7 +39,7 @@ module Airbrake
           :?
           (?<line>\d+)?  # Matches '105'
         \)
-      \z}x
+      \z}x.freeze
 
       # @return [Regexp] the pattern that tries to assume what a generic stack
       #   frame might look like, when exception's backtrace is set manually.
@@ -53,7 +53,7 @@ module Airbrake
         |
           :in\s(?<function>.+)   # Matches ":in func"
         )?                       # ... or nothing
-      \z}x
+      \z}x.freeze
 
       # @return [Regexp] the pattern that matches exceptions from PL/SQL such as
       #   ORA-06512: at "STORE.LI_LICENSES_PACK", line 1945
@@ -67,7 +67,7 @@ module Airbrake
         |
           #{GENERIC}
         )
-      \z/x
+      \z/x.freeze
 
       # @return [Regexp] the pattern that matches CoffeeScript backtraces
       #   usually coming from Rails & ExecJS
@@ -82,7 +82,7 @@ module Airbrake
           # Matches the Ruby part of the backtrace
           #{RUBY}
         )
-      \z/x
+      \z/x.freeze
     end
 
     # @return [Integer] how many first frames should include code hunks
@@ -95,6 +95,7 @@ module Airbrake
     # @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
 
@@ -147,13 +148,13 @@ module Airbrake
           return {
             file: match[:file],
             line: (Integer(match[:line]) if match[:line]),
-            function: match[:function]
+            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)"
+          "it: https://github.com/airbrake/airbrake-ruby/issues/new)",
         )
         { file: nil, line: nil, function: stackframe }
       end

data/lib/airbrake-ruby/benchmark.rb

@@ -2,7 +2,7 @@ module Airbrake
   # Benchmark benchmarks Ruby code.
   #
   # @since v4.2.4
-  # @api private
+  # @api public
   class Benchmark
     # Measures monotonic time for the given operation.
     #

data/lib/airbrake-ruby/code_hunk.rb

@@ -30,7 +30,7 @@ module Airbrake
       Airbrake::FileCache[file] ||= File.foreach(file)
     rescue StandardError => ex
       logger.error(
-        "#{self.class.name}: can't read code hunk for #{file}: #{ex}"
+        "#{self.class.name}: can't read code hunk for #{file}: #{ex}",
       )
       nil
     end

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

@@ -0,0 +1,77 @@
+module Airbrake
+  class Config
+    # Processor is a helper class, which is responsible for setting default
+    # config values, default notifier filters and remote configuration changes.
+    #
+    # @since v5.0.0
+    # @api private
+    class Processor
+      # @param [Airbrake::Config] config
+      # @return [Airbrake::Config::Processor]
+      def self.process(config)
+        new(config).process
+      end
+
+      # @param [Airbrake::Config] config
+      def initialize(config)
+        @config = config
+        @blocklist_keys = @config.blocklist_keys
+        @allowlist_keys = @config.allowlist_keys
+        @project_id = @config.project_id
+        @poll_callback = Airbrake::RemoteSettings::Callback.new(config)
+      end
+
+      # @param [Airbrake::NoticeNotifier] notifier
+      # @return [void]
+      def process_blocklist(notifier)
+        return if @blocklist_keys.none?
+
+        blocklist = Airbrake::Filters::KeysBlocklist.new(@blocklist_keys)
+        notifier.add_filter(blocklist)
+      end
+
+      # @param [Airbrake::NoticeNotifier] notifier
+      # @return [void]
+      def process_allowlist(notifier)
+        return if @allowlist_keys.none?
+
+        allowlist = Airbrake::Filters::KeysAllowlist.new(@allowlist_keys)
+        notifier.add_filter(allowlist)
+      end
+
+      # @return [Airbrake::RemoteSettings]
+      def process_remote_configuration
+        return unless @config.remote_config
+        return unless @project_id
+
+        # Never poll remote configuration in the test environment.
+        return if @config.environment == 'test'
+
+        # If the current environment is ignored, don't try to poll remote
+        # configuration.
+        return if @config.ignore_environments.include?(@config.environment)
+
+        RemoteSettings.poll(@project_id, @config.remote_config_host) do |data|
+          @poll_callback.call(data)
+        end
+      end
+
+      # @param [Airbrake::NoticeNotifier] notifier
+      # @return [void]
+      def add_filters(notifier)
+        return unless @config.root_directory
+
+        [
+          Airbrake::Filters::RootDirectoryFilter,
+          Airbrake::Filters::GitRevisionFilter,
+          Airbrake::Filters::GitRepositoryFilter,
+          Airbrake::Filters::GitLastCheckoutFilter,
+        ].each do |filter|
+          next if notifier.has_filter?(filter)
+
+          notifier.add_filter(filter.new(@config.root_directory))
+        end
+      end
+    end
+  end
+end

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

@@ -29,7 +29,7 @@ module Airbrake
             return promise.reject(
               "the 'environment' option must be configured " \
               "with a Symbol (or String), but '#{config.environment.class}' was " \
-              "provided: #{config.environment}"
+              "provided: #{config.environment}",
             )
           end
 
@@ -44,9 +44,13 @@ module Airbrake
         def check_notify_ability(config)
           promise = Airbrake::Promise.new
 
+          unless config.error_notifications
+            return promise.reject('error notifications are disabled')
+          end
+
           if ignored_environment?(config)
             return promise.reject(
-              "current environment '#{config.environment}' is ignored"
+              "current environment '#{config.environment}' is ignored",
             )
           end
 
@@ -57,12 +61,14 @@ module Airbrake
 
         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
 
@@ -74,7 +80,7 @@ module Airbrake
           if config.ignore_environments.any? && config.environment.nil?
             config.logger.warn(
               "#{LOG_LABEL} the 'environment' option is not set, " \
-              "'ignore_environments' has no effect"
+              "'ignore_environments' has no effect",
             )
           end
 

data/lib/airbrake-ruby/config.rb

@@ -44,7 +44,14 @@ module Airbrake
     # @return [String] the host, which provides the API endpoint to which
     #   exceptions should be sent
     # @api public
-    attr_accessor :host
+    # @since v5.0.0
+    attr_accessor :error_host
+
+    # @return [String] the host, which provides the API endpoint to which
+    #   APM data should be sent
+    # @api public
+    # @since v5.0.0
+    attr_accessor :apm_host
 
     # @return [String, Pathname] the working directory of your project
     # @api public
@@ -68,14 +75,14 @@ module Airbrake
     # @return [Array<String, Symbol, Regexp>] the keys, which should be
     #   filtered
     # @api public
-    # @since v1.2.0
-    attr_accessor :blacklist_keys
+    # @since v4.15.0
+    attr_accessor :allowlist_keys
 
-    # @return [Array<String, Symbol, Regexp>] the keys, which shouldn't be
+    # @return [Array<String, Symbol, Regexp>] the keys, which should be
     #   filtered
     # @api public
-    # @since v1.2.0
-    attr_accessor :whitelist_keys
+    # @since v4.15.0
+    attr_accessor :blocklist_keys
 
     # @return [Boolean] true if the library should attach code hunks to each
     #   frame in a backtrace, false otherwise
@@ -101,6 +108,36 @@ module Airbrake
     # @since v4.6.0
     attr_accessor :query_stats
 
+    # @return [Boolean] true if the library should send job/queue/worker stats
+    #   to Airbrake, false otherwise
+    # @api public
+    # @since v4.12.0
+    attr_accessor :job_stats
+
+    # @return [Boolean] true if the library should send error reports to
+    #   Airbrake, false otherwise
+    # @api public
+    # @since v5.0.0
+    attr_accessor :error_notifications
+
+    # @return [String] the host which should be used for fetching remote
+    #   configuration options
+    # @api public
+    # @since v5.0.0
+    attr_accessor :remote_config_host
+
+    # @return [String] true if notifier should periodically fetch remote
+    #   configuration, false otherwise
+    # @api public
+    # @since v5.2.0
+    attr_accessor :remote_config
+
+    # @return [Boolean] true if the library should keep a backlog of failed
+    #   notices or APM events and retry them after an interval, false otherwise
+    # @api public
+    # @since v6.2.0
+    attr_accessor :backlog
+
     class << self
       # @return [Config]
       attr_writer :instance
@@ -113,44 +150,51 @@ module Airbrake
 
     # @param [Hash{Symbol=>Object}] user_config the hash to be used to build the
     #   config
+    # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
     def initialize(user_config = {})
       self.proxy = {}
       self.queue_size = 100
       self.workers = 1
       self.code_hunks = true
-      self.logger = ::Logger.new(File::NULL)
+      self.logger = ::Logger.new(File::NULL).tap { |l| l.level = Logger::WARN }
       self.project_id = user_config[:project_id]
       self.project_key = user_config[:project_key]
-      self.host = 'https://api.airbrake.io'
+      self.error_host = self.apm_host = 'https://api.airbrake.io'
+      self.remote_config_host = 'https://notifier-configs.airbrake.io'
 
       self.ignore_environments = []
 
       self.timeout = user_config[:timeout]
 
-      self.blacklist_keys = []
-      self.whitelist_keys = []
+      self.blocklist_keys = []
+      self.allowlist_keys = []
 
       self.root_directory = File.realpath(
         (defined?(Bundler) && Bundler.root) ||
-        Dir.pwd
+        Dir.pwd,
       )
 
       self.versions = {}
       self.performance_stats = true
       self.performance_stats_flush_period = 15
-      self.query_stats = false
+      self.query_stats = true
+      self.job_stats = true
+      self.error_notifications = true
+      self.remote_config = true
+      self.backlog = true
 
       merge(user_config)
     end
+    # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
 
-    # The full URL to the Airbrake Notice API. Based on the +:host+ option.
+    # The full URL to the Airbrake Notice API. Based on the +:error_host+ option.
     # @return [URI] the endpoint address
-    def endpoint
-      @endpoint ||=
+    def error_endpoint
+      @error_endpoint ||=
         begin
-          self.host = ('https://' << host) if host !~ %r{\Ahttps?://}
+          self.error_host = ('https://' << error_host) if error_host !~ %r{\Ahttps?://}
           api = "api/v3/projects/#{project_id}/notices"
-          URI.join(host, api)
+          URI.join(error_host, api)
         end
     end
 
@@ -206,18 +250,33 @@ module Airbrake
 
     # @return [Promise] resolved promise if neither of the performance options
     #   reject it, false otherwise
-    def check_performance_options(resource)
+    def check_performance_options(metric)
       promise = Airbrake::Promise.new
 
       if !performance_stats
         promise.reject("The Performance Stats feature is disabled")
-      elsif resource.is_a?(Airbrake::Query) && !query_stats
+      elsif metric.is_a?(Airbrake::Query) && !query_stats
         promise.reject("The Query Stats feature is disabled")
+      elsif metric.is_a?(Airbrake::Queue) && !job_stats
+        promise.reject("The Job Stats feature is disabled")
       else
         promise
       end
     end
 
+    HOST_DEPRECATION_MSG = "**Airbrake: the 'host' option is deprecated. Use " \
+      "'error_host' instead".freeze
+
+    def host
+      logger.warn(HOST_DEPRECATION_MSG)
+      @error_host
+    end
+
+    def host=(value)
+      logger.warn(HOST_DEPRECATION_MSG)
+      @error_host = value
+    end
+
     private
 
     def set_option(option, value)