airbrake-ruby 4.6.0 → 6.2.2

data/lib/airbrake-ruby/remote_settings/callback.rb

@@ -0,0 +1,44 @@
+module Airbrake
+  class RemoteSettings
+    # Callback is a class that provides a callback for the config poller, which
+    # updates the local config according to the data.
+    #
+    # @api private
+    # @since v5.0.2
+    class Callback
+      def initialize(config)
+        @config = config
+        @orig_error_notifications = config.error_notifications
+        @orig_performance_stats = config.performance_stats
+      end
+
+      # @param [Airbrake::RemoteSettings::SettingsData] data
+      # @return [void]
+      def call(data)
+        @config.logger.debug do
+          "#{LOG_LABEL} applying remote settings: #{data.to_h}"
+        end
+
+        @config.error_host = data.error_host if data.error_host
+        @config.apm_host = data.apm_host if data.apm_host
+
+        process_error_notifications(data)
+        process_performance_stats(data)
+      end
+
+      private
+
+      def process_error_notifications(data)
+        return unless @orig_error_notifications
+
+        @config.error_notifications = data.error_notifications?
+      end
+
+      def process_performance_stats(data)
+        return unless @orig_performance_stats
+
+        @config.performance_stats = data.performance_stats?
+      end
+    end
+  end
+end

data/lib/airbrake-ruby/remote_settings/settings_data.rb

@@ -0,0 +1,116 @@
+module Airbrake
+  class RemoteSettings
+    # SettingsData is a container, which wraps JSON payload returned by the
+    # remote settings API. It exposes the payload via convenient methods and
+    # also ensures that in case some data from the payload is missing, a default
+    # value would be returned instead.
+    #
+    # @example
+    #   # Create the object and pass initial data (empty hash).
+    #   settings_data = SettingsData.new({})
+    #
+    #   settings_data.interval #=> 600
+    #
+    # @since v5.0.0
+    # @api private
+    class SettingsData
+      # @return [Integer] how frequently we should poll the config API
+      DEFAULT_INTERVAL = 600
+
+      # @return [String] API version of the S3 API to poll
+      API_VER = '2020-06-18'.freeze
+
+      # @return [String] what path to poll
+      CONFIG_ROUTE_PATTERN =
+        "%<host>s/#{API_VER}/config/%<project_id>s/config.json".freeze
+
+      # @return [Hash{Symbol=>String}] the hash of all supported settings where
+      #   the value is the name of the setting returned by the API
+      SETTINGS = {
+        errors: 'errors'.freeze,
+        apm: 'apm'.freeze,
+      }.freeze
+
+      # @param [Integer] project_id
+      # @param [Hash{String=>Object}] data
+      def initialize(project_id, data)
+        @project_id = project_id
+        @data = data
+      end
+
+      # Merges the given +hash+ with internal data.
+      #
+      # @param [Hash{String=>Object}] hash
+      # @return [self]
+      def merge!(hash)
+        @data.merge!(hash)
+
+        self
+      end
+
+      # @return [Integer] how frequently we should poll for the config
+      def interval
+        return DEFAULT_INTERVAL if !@data.key?('poll_sec') || !@data['poll_sec']
+
+        @data['poll_sec'] > 0 ? @data['poll_sec'] : DEFAULT_INTERVAL
+      end
+
+      # @param [String] remote_config_host
+      # @return [String] where the config is stored on S3.
+      def config_route(remote_config_host)
+        if @data['config_route'] && !@data['config_route'].empty?
+          return "#{remote_config_host.chomp('/')}/#{@data['config_route']}"
+        end
+
+        format(
+          CONFIG_ROUTE_PATTERN,
+          host: remote_config_host.chomp('/'),
+          project_id: @project_id,
+        )
+      end
+
+      # @return [Boolean] whether error notifications are enabled
+      def error_notifications?
+        return true unless (s = find_setting(SETTINGS[:errors]))
+
+        s['enabled']
+      end
+
+      # @return [Boolean] whether APM is enabled
+      def performance_stats?
+        return true unless (s = find_setting(SETTINGS[:apm]))
+
+        s['enabled']
+      end
+
+      # @return [String, nil] the host, which provides the API endpoint to which
+      #   exceptions should be sent
+      def error_host
+        return unless (s = find_setting(SETTINGS[:errors]))
+
+        s['endpoint']
+      end
+
+      # @return [String, nil] the host, which provides the API endpoint to which
+      #   APM data should be sent
+      def apm_host
+        return unless (s = find_setting(SETTINGS[:apm]))
+
+        s['endpoint']
+      end
+
+      # @return [Hash{String=>Object}] raw representation of JSON payload
+      def to_h
+        @data.dup
+      end
+
+      private
+
+      def find_setting(name)
+        return unless @data.key?('settings')
+
+        @data['settings'].find { |s| s['name'] == name }
+      end
+    end
+  end
+end

data/lib/airbrake-ruby/remote_settings.rb

@@ -0,0 +1,128 @@
+module Airbrake
+  # RemoteSettings polls the remote config of the passed project at fixed
+  # intervals. The fetched config is yielded as a callback parameter so that the
+  # invoker can define read config values. Supports proxies.
+  #
+  # @example Disable/enable error notifications based on the remote value
+  #   RemoteSettings.poll do |data|
+  #     config.error_notifications = data.error_notifications?
+  #   end
+  #
+  # @since v5.0.0
+  # @api private
+  class RemoteSettings
+    include Airbrake::Loggable
+
+    # @return [Hash{Symbol=>String}] metadata to be attached to every GET
+    #   request
+    QUERY_PARAMS = URI.encode_www_form(
+      notifier_name: Airbrake::NOTIFIER_INFO[:name],
+      notifier_version: Airbrake::NOTIFIER_INFO[:version],
+      os: RUBY_PLATFORM,
+      language: "#{RUBY_ENGINE}/#{RUBY_VERSION}".freeze,
+    ).freeze
+
+    # @return [String]
+    HTTP_OK = '200'.freeze
+
+    # Polls remote config of the given project.
+    #
+    # @param [Integer] project_id
+    # @param [String] host
+    # @yield [data]
+    # @yieldparam data [Airbrake::RemoteSettings::SettingsData]
+    # @return [Airbrake::RemoteSettings]
+    def self.poll(project_id, host, &block)
+      new(project_id, host, &block).poll
+    end
+
+    # @param [Integer] project_id
+    # @yield [data]
+    # @yieldparam data [Airbrake::RemoteSettings::SettingsData]
+    def initialize(project_id, host, &block)
+      @data = SettingsData.new(project_id, {})
+      @host = host
+      @block = block
+      @config = Airbrake::Config.instance
+      @poll = nil
+    end
+
+    # Polls remote config of the given project in background.
+    #
+    # @return [self]
+    def poll
+      @poll ||= Thread.new do
+        @block.call(@data)
+
+        loop do
+          @block.call(@data.merge!(fetch_config))
+          sleep(@data.interval)
+        end
+      end
+
+      self
+    end
+
+    # Stops the background poller thread.
+    #
+    # @return [void]
+    def stop_polling
+      @poll.kill if @poll
+    end
+
+    private
+
+    def fetch_config
+      uri = build_config_uri
+      https = build_https(uri)
+      req = Net::HTTP::Get.new(uri.request_uri)
+      response = nil
+
+      begin
+        response = https.request(req)
+      rescue StandardError => ex
+        reason = "#{LOG_LABEL} HTTP error: #{ex}"
+        logger.error(reason)
+        return {}
+      end
+
+      unless response.code == HTTP_OK
+        logger.error(response.body)
+        return {}
+      end
+
+      json = nil
+      begin
+        json = JSON.parse(response.body)
+      rescue JSON::ParserError => ex
+        logger.error(ex)
+        return {}
+      end
+
+      json
+    end
+
+    def build_config_uri
+      uri = URI(@data.config_route(@host))
+      uri.query = QUERY_PARAMS
+      uri
+    end
+
+    def build_https(uri)
+      Net::HTTP.new(uri.host, uri.port, *proxy_params).tap do |https|
+        https.use_ssl = uri.is_a?(URI::HTTPS)
+        if @config.timeout
+          https.open_timeout = @config.timeout
+          https.read_timeout = @config.timeout
+        end
+      end
+    end
+
+    def proxy_params
+      return unless @config.proxy.key?(:host)
+
+      [@config.proxy[:host], @config.proxy[:port], @config.proxy[:user],
+       @config.proxy[:password]]
+    end
+  end
+end

data/lib/airbrake-ruby/request.rb

@@ -4,20 +4,28 @@ module Airbrake
   # @see Airbrake.notify_request
   # @api public
   # @since v3.2.0
-  # rubocop:disable Metrics/BlockLength
-  Request = Struct.new(:method, :route, :status_code, :start_time, :end_time) do
+  class Request
     include HashKeyable
     include Ignorable
     include Stashable
+    include Mergeable
+    include Grouppable
+
+    attr_accessor :method, :route, :status_code, :timing, :time
 
     def initialize(
       method:,
       route:,
       status_code:,
-      start_time:,
-      end_time: Time.now
+      timing: nil,
+      time: Time.now
     )
-      super(method, route, status_code, start_time, end_time)
+      @time_utc = TimeTruncate.utc_truncate_minutes(time)
+      @method = method
+      @route = route
+      @status_code = status_code
+      @timing = timing
+      @time = time
     end
 
     def destination
@@ -28,18 +36,13 @@ module Airbrake
       'routes'
     end
 
-    def groups
-      {}
-    end
-
     def to_h
       {
         'method' => method,
         'route' => route,
         'statusCode' => status_code,
-        'time' => TimeTruncate.utc_truncate_minutes(start_time)
+        'time' => @time_utc,
       }.delete_if { |_key, val| val.nil? }
     end
   end
-  # rubocop:enable Metrics/BlockLength
 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/stat.rb

@@ -1,63 +1,57 @@
 require 'base64'
 
-# rubocop:disable Metrics/BlockLength
 module Airbrake
   # Stat is a data structure that allows accumulating performance data (route
   # performance, SQL query performance and such). It's powered by TDigests.
   #
-  # Usually, one Stat corresponds to one resource (route or query,
+  # Usually, one Stat corresponds to one metric (route or query,
   # etc.). Incrementing a stat means pushing new performance statistics.
   #
   # @example
   #   stat = Airbrake::Stat.new
-  #   stat.increment(Time.now - 200)
+  #   stat.increment_ms(2000)
   #   stat.to_h # Pack and serialize data so it can be transmitted.
   #
   # @since v3.2.0
-  Stat = Struct.new(:count, :sum, :sumsq, :tdigest) do
-    # @param [Integer] count How many times this stat was incremented
+  class Stat
+    attr_accessor :sum, :sumsq, :tdigest
+
     # @param [Float] sum The sum of duration in milliseconds
     # @param [Float] sumsq The squared sum of duration in milliseconds
     # @param [TDigest::TDigest] tdigest Packed durations. By default,
     #   compression is 20
-    def initialize(count: 0, sum: 0.0, sumsq: 0.0, tdigest: TDigest.new(0.05))
-      super(count, sum, sumsq, tdigest)
+    def initialize(sum: 0.0, sumsq: 0.0, tdigest: TDigest.new(0.05))
+      @sum = sum
+      @sumsq = sumsq
+      @tdigest = tdigest
+      @mutex = Mutex.new
     end
 
     # @return [Hash{String=>Object}] stats as a hash with compressed TDigest
     #   (serialized as base64)
     def to_h
-      tdigest.compress!
-      {
-        'count' => count,
-        'sum' => sum,
-        'sumsq' => sumsq,
-        'tdigest' => Base64.strict_encode64(tdigest.as_small_bytes)
-      }
-    end
-
-    # Increments count and updates performance with the difference of +end_time+
-    # and +start_time+.
-    #
-    # @param [Date] start_time
-    # @param [Date] end_time
-    # @return [void]
-    def increment(start_time, end_time = nil)
-      end_time ||= Time.new
-      increment_ms((end_time - start_time) * 1000)
+      @mutex.synchronize do
+        tdigest.compress!
+        {
+          'count' => tdigest.size,
+          'sum' => sum,
+          'sumsq' => sumsq,
+          'tdigest' => Base64.strict_encode64(tdigest.as_small_bytes),
+        }
+      end
     end
 
-    # Increments count and updates performance with given +ms+ value.
+    # Increments tdigest timings and updates tdigest with given +ms+ value.
     #
     # @param [Float] ms
     # @return [void]
     def increment_ms(ms)
-      self.count += 1
-
-      self.sum += ms
-      self.sumsq += ms * ms
+      @mutex.synchronize do
+        self.sum += ms
+        self.sumsq += ms * ms
 
-      tdigest.push(ms)
+        tdigest.push(ms)
+      end
     end
 
     # We define custom inspect so that we weed out uninformative TDigest, which
@@ -65,9 +59,8 @@ module Airbrake
     #
     # @return [String]
     def inspect
-      "#<struct Airbrake::Stat count=#{count}, sum=#{sum}, sumsq=#{sumsq}>"
+      "#<struct Airbrake::Stat count=#{tdigest.size}, sum=#{sum}, sumsq=#{sumsq}>"
     end
-    alias_method :pretty_print, :inspect
+    alias pretty_print inspect
   end
 end
-# rubocop:enable Metrics/BlockLength

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.
@@ -23,18 +38,14 @@ module Airbrake
     # @param [#to_json] data
     # @param [URI::HTTPS] endpoint
     # @return [Hash{String=>String}] the parsed HTTP response
-    def send(data, promise, endpoint = @config.endpoint)
+    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,14 +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)
@@ -79,12 +98,25 @@ module Airbrake
       req['Authorization'] = "Bearer #{@config.project_key}"
       req['Content-Type'] = CONTENT_TYPE
       req['User-Agent'] =
-        "#{Airbrake::Notice::NOTIFIER[: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)