airbrake-ruby 6.1.0-java → 6.2.0-java

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 43fd8f74ef78e82c2ed46c8dc3ecd389a6c6ffcbdb8b20b22f1bf02e2ce4345d
-  data.tar.gz: 63c8aa81c33948f26ead281e81769a274dbca9740880a420d62b4d951b352984
+  metadata.gz: cd0d346a1833ed5852ebdb32b6bd3fae7794c5fc8a14113858395f78c488a9a9
+  data.tar.gz: d579021d4b619b7307643559ca1a0d19f22782305b3a91a56c25d6e393402949
 SHA512:
-  metadata.gz: 1e2f56b1d4af8f98cbb2c8026fc3b2f06178cff6be5fcfe42117693038be80a27513c6b235dc8b8a47900ee66aed4cadc5c0fd4e7c442fcf0f10af97b6df5a5b
-  data.tar.gz: 59bf1fd79c2467401aabc0c352397d82bae83805cb54ccac40c5ca132dfcfdefa5281a8ba11dc96f67d569405837af61aeb05a22ce9e2f3425d0ecc4a1c69251
+  metadata.gz: c4b5314eddf0dc211a995ccb7a3860f11580e9bd9a98d0d76b3550eec77b140f0dff54b6a8e60091750a827d3286ad275c9f7e46f10b36f7465806a7037f1bbe
+  data.tar.gz: 1deb29c06f902730deb860150354da8c8a781cf5082daeb5305c47b33d6c6221d5d35fdc6ad2311d4dff22923cc0b015e6e7ceac756365709dc69987e90d7326

data/lib/airbrake-ruby/async_sender.rb

@@ -5,20 +5,18 @@ module Airbrake
   # @api private
   # @since v1.0.0
   class AsyncSender
-    include Loggable
-
     def initialize(method = :post, name = 'async-sender')
       @config = Airbrake::Config.instance
-      @method = method
+      @sync_sender = SyncSender.new(method)
       @name = name
     end
 
     # Asynchronously sends a notice to Airbrake.
     #
-    # @param [Hash] payload Whatever needs to be sent
+    # @param [Airbrake::Notice] payload Whatever needs to be sent
     # @return [Airbrake::Promise]
-    def send(payload, promise, endpoint = @config.error_endpoint)
-      unless thread_pool << [payload, promise, endpoint]
+    def send(notice, promise, endpoint = @config.error_endpoint)
+      unless thread_pool << [notice, promise, endpoint]
         return promise.reject(
           "AsyncSender has reached its capacity of #{@config.queue_size}",
         )
@@ -29,6 +27,7 @@ module Airbrake
 
     # @return [void]
     def close
+      @sync_sender.close
       thread_pool.close
     end
 
@@ -45,15 +44,12 @@ module Airbrake
     private
 
     def thread_pool
-      @thread_pool ||= begin
-        sender = SyncSender.new(@method)
-        ThreadPool.new(
-          name: @name,
-          worker_size: @config.workers,
-          queue_size: @config.queue_size,
-          block: proc { |args| sender.send(*args) },
-        )
-      end
+      @thread_pool ||= ThreadPool.new(
+        name: @name,
+        worker_size: @config.workers,
+        queue_size: @config.queue_size,
+        block: proc { |args| @sync_sender.send(*args) },
+      )
     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/config.rb

@@ -136,6 +136,12 @@ module Airbrake
     # @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
@@ -180,6 +186,7 @@ module Airbrake
       self.job_stats = true
       self.error_notifications = true
       self.remote_config = true
+      self.backlog = true
 
       merge(user_config)
     end

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

@@ -27,7 +27,7 @@ module Airbrake
         @git_path = File.join(root_directory, '.git')
         @weight = 116
         @last_checkout = nil
-        @deploy_username = ENV['AIRBRAKE_DEPLOY_USERNAME']
+        @deploy_username = ENV.fetch('AIRBRAKE_DEPLOY_USERNAME', nil)
       end
 
       # @macro call_filter

data/lib/airbrake-ruby/nested_exception.rb

@@ -9,6 +9,18 @@ module Airbrake
     #   can unwrap. Exceptions that have a longer cause chain will be ignored
     MAX_NESTED_EXCEPTIONS = 3
 
+    # On Ruby 3.1+, the error highlighting gem can produce messages that can
+    # span multiple lines. We don't display multiline error messages in the
+    # title of the notice in the Airbrake dashboard. Therefore, we want to strip
+    # out the higlighting part so that the errors look consistent. The full
+    # message with the exception will be attached to the notice body.
+    #
+    # @return [String]
+    RUBY_31_ERROR_HIGHLIGHTING_DIVIDER = "\n\n".freeze
+
+    # @return [Hash] the options for +String#encode+
+    ENCODING_OPTIONS = { invalid: :replace, undef: :replace }.freeze
+
     def initialize(exception)
       @exception = exception
     end
@@ -16,7 +28,7 @@ module Airbrake
     def as_json
       unwind_exceptions.map do |exception|
         { type: exception.class.name,
-          message: exception.message,
+          message: message(exception),
           backtrace: Backtrace.parse(exception) }
       end
     end
@@ -34,5 +46,14 @@ module Airbrake
 
       exception_list
     end
+
+    def message(exception)
+      return unless (msg = exception.message)
+
+      msg
+        .encode(Encoding::UTF_8, **ENCODING_OPTIONS)
+        .split(RUBY_31_ERROR_HIGHLIGHTING_DIVIDER)
+        .first
+    end
   end
 end

data/lib/airbrake-ruby/notice.rb

@@ -49,16 +49,17 @@ module Airbrake
     # @api private
     def initialize(exception, params = {})
       @config = Airbrake::Config.instance
+      @truncator = Airbrake::Truncator.new(PAYLOAD_MAX_SIZE)
+
       @payload = {
         errors: NestedException.new(exception).as_json,
-        context: context,
+        context: context(exception),
         environment: {
           program_name: $PROGRAM_NAME,
         },
         session: {},
         params: params,
       }
-      @truncator = Airbrake::Truncator.new(PAYLOAD_MAX_SIZE)
 
       stash[:exception] = exception
     end
@@ -118,7 +119,7 @@ module Airbrake
 
     private
 
-    def context
+    def context(exception)
       {
         version: @config.app_version,
         versions: @config.versions,
@@ -132,6 +133,7 @@ module Airbrake
         hostname: HOSTNAME,
 
         severity: DEFAULT_SEVERITY,
+        error_message: @truncator.truncate(exception.message),
       }.merge(CONTEXT).delete_if { |_key, val| val.nil? || val.empty? }
     end
 

data/lib/airbrake-ruby/notice_notifier.rb

@@ -68,6 +68,7 @@ module Airbrake
 
     # @see Airbrake.close
     def close
+      @sync_sender.close
       @async_sender.close
     end
 

data/lib/airbrake-ruby/performance_notifier.rb

@@ -50,6 +50,7 @@ module Airbrake
     def close
       @payload.synchronize do
         @schedule_flush.kill if @schedule_flush
+        @sync_sender.close
         @async_sender.close
       end
     end

data/lib/airbrake-ruby/response.rb

@@ -8,9 +8,56 @@ module Airbrake
     # @return [Integer] the limit of the response body
     TRUNCATE_LIMIT = 100
 
+    # @return [Integer] HTTP code returned when the server cannot or will not
+    #   process the request due to something that is perceived to be a client
+    #   error
+    # @since v6.2.0
+    BAD_REQUEST = 400
+
+    # @return [Integer] HTTP code returned when client request has not been
+    #   completed because it lacks valid authentication credentials for the
+    #   requested resource
+    # @since v6.2.0
+    UNAUTHORIZED = 401
+
+    # @return [Integer] HTTP code returned when the server understands the
+    #   request but refuses to authorize it
+    # @since v6.2.0
+    FORBIDDEN = 403
+
+    # @return [Integer] HTTP code returned when the server would like to shut
+    #   down this unused connection
+    # @since v6.2.0
+    REQUEST_TIMEOUT = 408
+
+    # @return [Integer] HTTP code returned when there's a request conflict with
+    #   the current state of the target resource
+    # @since v6.2.0
+    CONFLICT = 409
+
+    # @return [Integer]
+    # @since v6.2.0
+    ENHANCE_YOUR_CALM = 420
+
     # @return [Integer] HTTP code returned when an IP sends over 10k/min notices
     TOO_MANY_REQUESTS = 429
 
+    # @return [Integer] HTTP code returned when the server encountered an
+    #   unexpected condition that prevented it from fulfilling the request
+    # @since v6.2.0
+    INTERNAL_SERVER_ERROR = 500
+
+    # @return [Integer] HTTP code returened when the server, while acting as a
+    #   gateway or proxy, received an invalid response from the upstream server
+    # @since v6.2.0
+    BAD_GATEWAY = 502
+
+    # @return [Integer] HTTP code returened when the server, while acting as a
+    #   gateway or proxy, did not get a response in time from the upstream
+    #   server that it needed in order to complete the request
+    # @since v6.2.0
+    GATEWAY_TIMEOUT = 504
+
     class << self
       include Loggable
     end
@@ -33,24 +80,28 @@ module Airbrake
           parsed_body = JSON.parse(body)
           logger.debug("#{LOG_LABEL} #{name} (#{code}): #{parsed_body}")
           parsed_body
-        when 400, 401, 403, 420
+        when BAD_REQUEST, UNAUTHORIZED, FORBIDDEN, ENHANCE_YOUR_CALM
           parsed_body = JSON.parse(body)
           logger.error("#{LOG_LABEL} #{parsed_body['message']}")
-          parsed_body
+          parsed_body.merge('code' => code, 'error' => parsed_body['message'])
         when TOO_MANY_REQUESTS
           parsed_body = JSON.parse(body)
           msg = "#{LOG_LABEL} #{parsed_body['message']}"
           logger.error(msg)
-          { 'error' => msg, 'rate_limit_reset' => rate_limit_reset(response) }
+          {
+            'code' => code,
+            'error' => msg,
+            'rate_limit_reset' => rate_limit_reset(response),
+          }
         else
           body_msg = truncated_body(body)
           logger.error("#{LOG_LABEL} unexpected code (#{code}). Body: #{body_msg}")
-          { 'error' => body_msg }
+          { 'code' => code, 'error' => body_msg }
         end
       rescue StandardError => ex
         body_msg = truncated_body(body)
         logger.error("#{LOG_LABEL} error while parsing body (#{ex}). Body: #{body_msg}")
-        { 'error' => ex.inspect }
+        { 'code' => code, 'error' => ex.inspect }
       end
     end
     # rubocop:enable Metrics/MethodLength, Metrics/AbcSize

data/lib/airbrake-ruby/sync_sender.rb

@@ -9,6 +9,20 @@ module Airbrake
     # @return [String] body for HTTP requests
     CONTENT_TYPE = 'application/json'.freeze
 
+    # @return [Array<Integer>] response codes that are good to be backlogged
+    # @since v6.2.0
+    BACKLOGGABLE_STATUS_CODES = [
+      Response::BAD_REQUEST,
+      Response::FORBIDDEN,
+      Response::ENHANCE_YOUR_CALM,
+      Response::REQUEST_TIMEOUT,
+      Response::CONFLICT,
+      Response::TOO_MANY_REQUESTS,
+      Response::INTERNAL_SERVER_ERROR,
+      Response::BAD_GATEWAY,
+      Response::GATEWAY_TIMEOUT,
+    ].freeze
+
     include Loggable
 
     # @param [Symbol] method HTTP method to use to send payload
@@ -16,6 +30,7 @@ module Airbrake
       @config = Airbrake::Config.instance
       @method = method
       @rate_limit_reset = Time.now
+      @backlog = Backlog.new(self) if @config.backlog
     end
 
     # Sends a POST or PUT request to the given +endpoint+ with the +data+ payload.
@@ -26,15 +41,11 @@ module Airbrake
     def send(data, promise, endpoint = @config.error_endpoint)
       return promise if rate_limited_ip?(promise)
 
-      response = nil
       req = build_request(endpoint, data)
-
       return promise if missing_body?(req, promise)
 
-      https = build_https(endpoint)
-
       begin
-        response = https.request(req)
+        response = build_https(endpoint).request(req)
       rescue StandardError => ex
         reason = "#{LOG_LABEL} HTTP error: #{ex}"
         logger.error(reason)
@@ -42,15 +53,22 @@ module Airbrake
       end
 
       parsed_resp = Response.parse(response)
-      if parsed_resp.key?('rate_limit_reset')
-        @rate_limit_reset = parsed_resp['rate_limit_reset']
-      end
+      handle_rate_limit(parsed_resp)
+      @backlog << [data, endpoint] if add_to_backlog?(parsed_resp)
 
       return promise.reject(parsed_resp['error']) if parsed_resp.key?('error')
 
       promise.resolve(parsed_resp)
     end
 
+    # Closes all the resources that this sender has allocated.
+    #
+    # @return [void]
+    # @since v6.2.0
+    def close
+      @backlog.close
+    end
+
     private
 
     def build_https(uri)
@@ -80,12 +98,25 @@ module Airbrake
       req['Authorization'] = "Bearer #{@config.project_key}"
       req['Content-Type'] = CONTENT_TYPE
       req['User-Agent'] =
-        "#{Airbrake::NOTIFIER_INFO[:name]}/#{Airbrake::AIRBRAKE_RUBY_VERSION}" \
-        " Ruby/#{RUBY_VERSION}"
+        "#{Airbrake::NOTIFIER_INFO[:name]}/#{Airbrake::AIRBRAKE_RUBY_VERSION} " \
+        "Ruby/#{RUBY_VERSION}"
 
       req
     end
 
+    def handle_rate_limit(parsed_resp)
+      return unless parsed_resp.key?('rate_limit_reset')
+
+      @rate_limit_reset = parsed_resp['rate_limit_reset']
+    end
+
+    def add_to_backlog?(parsed_resp)
+      return unless @backlog
+      return unless parsed_resp.key?('code')
+
+      BACKLOGGABLE_STATUS_CODES.include?(parsed_resp['code'])
+    end
+
     def proxy_params
       return unless @config.proxy.key?(:host)
 

data/lib/airbrake-ruby/version.rb

@@ -3,7 +3,7 @@
 module Airbrake
   # @return [String] the library version
   # @api public
-  AIRBRAKE_RUBY_VERSION = '6.1.0'.freeze
+  AIRBRAKE_RUBY_VERSION = '6.2.0'.freeze
 
   # @return [Hash{Symbol=>String}] the information about the notifier library
   # @since v5.0.0

data/lib/airbrake-ruby.rb

@@ -18,9 +18,9 @@ require 'airbrake-ruby/remote_settings/settings_data'
 require 'airbrake-ruby/remote_settings'
 require 'airbrake-ruby/promise'
 require 'airbrake-ruby/thread_pool'
+require 'airbrake-ruby/response'
 require 'airbrake-ruby/sync_sender'
 require 'airbrake-ruby/async_sender'
-require 'airbrake-ruby/response'
 require 'airbrake-ruby/nested_exception'
 require 'airbrake-ruby/ignorable'
 require 'airbrake-ruby/inspectable'
@@ -59,6 +59,7 @@ require 'airbrake-ruby/monotonic_time'
 require 'airbrake-ruby/timed_trace'
 require 'airbrake-ruby/queue'
 require 'airbrake-ruby/context'
+require 'airbrake-ruby/backlog'
 
 # Airbrake is a thin wrapper around instances of the notifier classes (such as
 # notice, performance & deploy notifiers). It creates a way to access them via a