airbrake-ruby 4.8.0

data/lib/airbrake-ruby/request.rb

@@ -0,0 +1,46 @@
+module Airbrake
+  # Request holds request data that powers route stats.
+  #
+  # @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
+    include HashKeyable
+    include Ignorable
+    include Stashable
+
+    def initialize(
+      method:,
+      route:,
+      status_code:,
+      start_time:,
+      end_time: Time.now
+    )
+      @start_time_utc = TimeTruncate.utc_truncate_minutes(start_time)
+      super(method, route, status_code, start_time, end_time)
+    end
+
+    def destination
+      'routes-stats'
+    end
+
+    def cargo
+      'routes'
+    end
+
+    def groups
+      {}
+    end
+
+    def to_h
+      {
+        'method' => method,
+        'route' => route,
+        'statusCode' => status_code,
+        'time' => @start_time_utc
+      }.delete_if { |_key, val| val.nil? }
+    end
+  end
+  # rubocop:enable Metrics/BlockLength
+end

data/lib/airbrake-ruby/response.rb

@@ -0,0 +1,74 @@
+module Airbrake
+  # Parses responses coming from the Airbrake API. Handles HTTP errors by
+  # logging them.
+  #
+  # @api private
+  # @since v1.0.0
+  module Response
+    # @return [Integer] the limit of the response body
+    TRUNCATE_LIMIT = 100
+
+    # @return [Integer] HTTP code returned when an IP sends over 10k/min notices
+    TOO_MANY_REQUESTS = 429
+
+    class << self
+      include Loggable
+    end
+
+    # Parses HTTP responses from the Airbrake API.
+    #
+    # @param [Net::HTTPResponse] response
+    # @return [Hash{String=>String}] parsed response
+    # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+    def self.parse(response)
+      code = response.code.to_i
+      body = response.body
+
+      begin
+        case code
+        when 200, 204
+          logger.debug("#{LOG_LABEL} #{name} (#{code}): #{body}")
+          { response.msg => response.body }
+        when 201
+          parsed_body = JSON.parse(body)
+          logger.debug("#{LOG_LABEL} #{name} (#{code}): #{parsed_body}")
+          parsed_body
+        when 400, 401, 403, 420
+          parsed_body = JSON.parse(body)
+          logger.error("#{LOG_LABEL} #{parsed_body['message']}")
+          parsed_body
+        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) }
+        else
+          body_msg = truncated_body(body)
+          logger.error("#{LOG_LABEL} unexpected code (#{code}). Body: #{body_msg}")
+          { '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 }
+      end
+    end
+    # rubocop:enable Metrics/MethodLength, Metrics/AbcSize
+
+    def self.truncated_body(body)
+      if body.nil?
+        '[EMPTY_BODY]'.freeze
+      elsif body.length > TRUNCATE_LIMIT
+        body[0..TRUNCATE_LIMIT] << '...'
+      else
+        body
+      end
+    end
+    private_class_method :truncated_body
+
+    def self.rate_limit_reset(response)
+      Time.now + response['X-RateLimit-Delay'].to_i
+    end
+    private_class_method :rate_limit_reset
+  end
+end

data/lib/airbrake-ruby/stashable.rb

@@ -0,0 +1,15 @@
+module Airbrake
+  # Stashable should be included in any class that wants the ability to stash
+  # arbitrary objects. It is mainly used by data objects that users can access
+  # through filters.
+  #
+  # @since v4.4.0
+  # @api private
+  module Stashable
+    # @return [Hash{Symbol=>Object}] the hash with arbitrary objects to be used
+    #   in filters
+    def stash
+      @stash ||= {}
+    end
+  end
+end

data/lib/airbrake-ruby/stat.rb

@@ -0,0 +1,73 @@
+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,
+  # etc.). Incrementing a stat means pushing new performance statistics.
+  #
+  # @example
+  #   stat = Airbrake::Stat.new
+  #   stat.increment(Time.now - 200)
+  #   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
+    # @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)
+    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)
+    end
+
+    # Increments count and updates performance with given +ms+ value.
+    #
+    # @param [Float] ms
+    # @return [void]
+    def increment_ms(ms)
+      self.count += 1
+
+      self.sum += ms
+      self.sumsq += ms * ms
+
+      tdigest.push(ms)
+    end
+
+    # We define custom inspect so that we weed out uninformative TDigest, which
+    # is also very slow to dump when we log Airbrake::Stat.
+    #
+    # @return [String]
+    def inspect
+      "#<struct Airbrake::Stat count=#{count}, sum=#{sum}, sumsq=#{sumsq}>"
+    end
+    alias_method :pretty_print, :inspect
+  end
+end
+# rubocop:enable Metrics/BlockLength

data/lib/airbrake-ruby/sync_sender.rb

@@ -0,0 +1,113 @@
+module Airbrake
+  # Responsible for sending data to Airbrake synchronously via PUT or POST
+  # methods. Supports proxies.
+  #
+  # @see AsyncSender
+  # @api private
+  # @since v1.0.0
+  class SyncSender
+    # @return [String] body for HTTP requests
+    CONTENT_TYPE = 'application/json'.freeze
+
+    include Loggable
+
+    # @param [Symbol] method HTTP method to use to send payload
+    def initialize(method = :post)
+      @config = Airbrake::Config.instance
+      @method = method
+      @rate_limit_reset = Time.now
+    end
+
+    # Sends a POST or PUT request to the given +endpoint+ with the +data+ payload.
+    #
+    # @param [#to_json] data
+    # @param [URI::HTTPS] endpoint
+    # @return [Hash{String=>String}] the parsed HTTP response
+    def send(data, promise, endpoint = @config.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)
+      rescue StandardError => ex
+        reason = "#{LOG_LABEL} HTTP error: #{ex}"
+        logger.error(reason)
+        return promise.reject(reason)
+      end
+
+      parsed_resp = Response.parse(response)
+      if parsed_resp.key?('rate_limit_reset')
+        @rate_limit_reset = parsed_resp['rate_limit_reset']
+      end
+
+      return promise.reject(parsed_resp['error']) if parsed_resp.key?('error')
+      promise.resolve(parsed_resp)
+    end
+
+    private
+
+    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 build_request(uri, data)
+      req =
+        if @method == :put
+          Net::HTTP::Put.new(uri.request_uri)
+        else
+          Net::HTTP::Post.new(uri.request_uri)
+        end
+
+      build_request_body(req, data)
+    end
+
+    def build_request_body(req, data)
+      req.body = data.to_json
+
+      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}"
+
+      req
+    end
+
+    def proxy_params
+      return unless @config.proxy.key?(:host)
+
+      [@config.proxy[:host], @config.proxy[:port], @config.proxy[:user],
+       @config.proxy[:password]]
+    end
+
+    def rate_limited_ip?(promise)
+      rate_limited = Time.now < @rate_limit_reset
+      promise.reject("#{LOG_LABEL} IP is rate limited") if rate_limited
+      rate_limited
+    end
+
+    def missing_body?(req, promise)
+      missing = req.body.nil?
+
+      if missing
+        reason = "#{LOG_LABEL} data was not sent because of missing body"
+        logger.error(reason)
+        promise.reject(reason)
+      end
+
+      missing
+    end
+  end
+end

data/lib/airbrake-ruby/tdigest.rb

@@ -0,0 +1,393 @@
+require 'rbtree'
+
+module Airbrake
+  # Ruby implementation of Ted Dunning's t-digest data structure.
+  #
+  # This implementation is imported from https://github.com/castle/tdigest with
+  # custom modifications. Huge thanks to Castle for the implementation :beer:
+  #
+  # The difference is that we pack with Big Endian (unlike Native Endian in
+  # Castle's version). Our backend does not permit little endian.
+  #
+  # @see https://github.com/tdunning/t-digest
+  # @see https://github.com/castle/tdigest
+  # @api private
+  # @since v3.2.0
+  #
+  # rubocop:disable Metrics/ClassLength
+  class TDigest
+    VERBOSE_ENCODING = 1
+    SMALL_ENCODING   = 2
+
+    # Centroid represents a number of data points.
+    # @api private
+    # @since v3.2.0
+    class Centroid
+      attr_accessor :mean, :n, :cumn, :mean_cumn
+      def initialize(mean, n, cumn, mean_cumn = nil)
+        @mean      = mean
+        @n         = n
+        @cumn      = cumn
+        @mean_cumn = mean_cumn
+      end
+
+      def as_json(_ = nil)
+        { m: mean, n: n }
+      end
+    end
+
+    attr_accessor :centroids
+    def initialize(delta = 0.01, k = 25, cx = 1.1)
+      @delta = delta
+      @k = k
+      @cx = cx
+      @centroids = RBTree.new
+      @nreset = 0
+      @n = 0
+      reset!
+    end
+
+    def +(other)
+      # Uses delta, k and cx from the caller
+      t = self.class.new(@delta, @k, @cx)
+      data = centroids.values + other.centroids.values
+      t.push_centroid(data.delete_at(rand(data.length))) while data.any?
+      t
+    end
+
+    def as_bytes
+      # compression as defined by Java implementation
+      size = @centroids.size
+      output = [VERBOSE_ENCODING, compression, size]
+      output += @centroids.map { |_, c| c.mean }
+      output += @centroids.map { |_, c| c.n }
+      output.pack("NGNG#{size}N#{size}")
+    end
+
+    # rubocop:disable Metrics/AbcSize
+    def as_small_bytes
+      size = @centroids.size
+      output = [self.class::SMALL_ENCODING, compression, size]
+      x = 0
+      # delta encoding allows saving 4-bytes floats
+      mean_arr = @centroids.map do |_, c|
+        val = c.mean - x
+        x = c.mean
+        val
+      end
+      output += mean_arr
+      # Variable length encoding of numbers
+      c_arr = @centroids.each_with_object([]) do |(_, c), arr|
+        k = 0
+        n = c.n
+        while n < 0 || n > 0x7f
+          b = 0x80 | (0x7f & n)
+          arr << b
+          n = n >> 7
+          k += 1
+          raise 'Unreasonable large number' if k > 6
+        end
+        arr << n
+      end
+      output += c_arr
+      output.pack("NGNg#{size}C#{size}")
+    end
+    # rubocop:enable Metrics/AbcSize
+
+    def as_json(_ = nil)
+      @centroids.map { |_, c| c.as_json }
+    end
+
+    def bound_mean(x)
+      upper = @centroids.upper_bound(x)
+      lower = @centroids.lower_bound(x)
+      [lower[1], upper[1]]
+    end
+
+    def bound_mean_cumn(cumn)
+      last_c = nil
+      bounds = []
+      @centroids.each_value do |v|
+        if v.mean_cumn == cumn
+          bounds << v
+          break
+        elsif v.mean_cumn > cumn
+          bounds << last_c
+          bounds << v
+          break
+        else
+          last_c = v
+        end
+      end
+      # If still no results, pick lagging value if any
+      bounds << last_c if bounds.empty? && !last_c.nil?
+
+      bounds
+    end
+
+    def compress!
+      points = to_a
+      reset!
+      push_centroid(points.shuffle)
+      _cumulate(true, true)
+      nil
+    end
+
+    def compression
+      1 / @delta
+    end
+
+    def find_nearest(x)
+      return nil if size == 0
+
+      ceil  = @centroids.upper_bound(x)
+      floor = @centroids.lower_bound(x)
+
+      return floor[1] if ceil.nil?
+      return ceil[1]  if floor.nil?
+
+      ceil_key  = ceil[0]
+      floor_key = floor[0]
+
+      if (floor_key - x).abs < (ceil_key - x).abs
+        floor[1]
+      else
+        ceil[1]
+      end
+    end
+
+    def merge!(other)
+      push_centroid(other.centroids.values.shuffle)
+      self
+    end
+
+    # rubocop:disable Metrics/PerceivedComplexity, Metrics/AbcSize
+    # rubocop:disable Metrics/CyclomaticComplexity
+    def p_rank(x)
+      is_array = x.is_a? Array
+      x = [x] unless is_array
+
+      min = @centroids.first
+      max = @centroids.last
+
+      x.map! do |item|
+        if size == 0
+          nil
+        elsif item < min[1].mean
+          0.0
+        elsif item > max[1].mean
+          1.0
+        else
+          _cumulate(true)
+          bound = bound_mean(item)
+          lower, upper = bound
+          mean_cumn = lower.mean_cumn
+          if lower != upper
+            mean_cumn += (item - lower.mean) * (upper.mean_cumn - lower.mean_cumn) \
+              / (upper.mean - lower.mean)
+          end
+          mean_cumn / @n
+        end
+      end
+      is_array ? x : x.first
+    end
+    # rubocop:enable Metrics/PerceivedComplexity, Metrics/AbcSize
+    # rubocop:enable Metrics/CyclomaticComplexity
+
+    # rubocop:disable Metrics/PerceivedComplexity, Metrics/CyclomaticComplexity
+    # rubocop:disable Metrics/AbcSize
+    def percentile(p)
+      is_array = p.is_a? Array
+      p = [p] unless is_array
+      p.map! do |item|
+        unless (0..1).cover?(item)
+          raise ArgumentError, "p should be in [0,1], got #{item}"
+        end
+        if size == 0
+          nil
+        else
+          _cumulate(true)
+          h = @n * item
+          lower, upper = bound_mean_cumn(h)
+          if lower.nil? && upper.nil?
+            nil
+          elsif upper == lower || lower.nil? || upper.nil?
+            (lower || upper).mean
+          elsif h == lower.mean_cumn
+            lower.mean
+          else
+            upper.mean
+          end
+        end
+      end
+      is_array ? p : p.first
+    end
+    # rubocop:enable Metrics/PerceivedComplexity, Metrics/CyclomaticComplexity
+    # rubocop:enable Metrics/AbcSize
+
+    def push(x, n = 1)
+      x = [x] unless x.is_a? Array
+      x.each { |value| _digest(value, n) }
+    end
+
+    def push_centroid(c)
+      c = [c] unless c.is_a? Array
+      c.each { |centroid| _digest(centroid.mean, centroid.n) }
+    end
+
+    def reset!
+      @centroids.clear
+      @n = 0
+      @nreset += 1
+      @last_cumulate = 0
+    end
+
+    def size
+      @n || 0
+    end
+
+    def to_a
+      @centroids.map { |_, c| c }
+    end
+
+    # rubocop:disable Metrics/PerceivedComplexity, Metrics/MethodLength
+    # rubocop:disable Metrics/CyclomaticComplexity, Metrics/AbcSize
+    def self.from_bytes(bytes)
+      format, compression, size = bytes.unpack('NGN')
+      tdigest = new(1 / compression)
+
+      start_idx = 16 # after header
+      case format
+      when VERBOSE_ENCODING
+        array = bytes[start_idx..-1].unpack("G#{size}N#{size}")
+        means, counts = array.each_slice(size).to_a if array.any?
+      when SMALL_ENCODING
+        means = bytes[start_idx..(start_idx + 4 * size)].unpack("g#{size}")
+        # Decode delta encoding of means
+        x = 0
+        means.map! do |m|
+          m += x
+          x = m
+          m
+        end
+        counts_bytes = bytes[(start_idx + 4 * size)..-1].unpack('C*')
+        counts = []
+        # Decode variable length integer bytes
+        size.times do
+          v = counts_bytes.shift
+          z = 0x7f & v
+          shift = 7
+          while (v & 0x80) != 0
+            raise 'Shift too large in decode' if shift > 28
+            v = counts_bytes.shift || 0
+            z += (v & 0x7f) << shift
+            shift += 7
+          end
+          counts << z
+        end
+        # This shouldn't happen
+        raise 'Mismatch' unless counts.size == means.size
+      else
+        raise 'Unknown compression format'
+      end
+
+      means.zip(counts).each { |val| tdigest.push(val[0], val[1]) } if means && counts
+
+      tdigest
+    end
+    # rubocop:enable Metrics/PerceivedComplexity, Metrics/MethodLength
+    # rubocop:enable Metrics/CyclomaticComplexity, Metrics/AbcSize
+
+    def self.from_json(array)
+      tdigest = new
+      # Handle both string and symbol keys
+      array.each { |a| tdigest.push(a['m'] || a[:m], a['n'] || a[:n]) }
+      tdigest
+    end
+
+    private
+
+    def _add_weight(nearest, x, n)
+      nearest.mean += n * (x - nearest.mean) / (nearest.n + n) unless x == nearest.mean
+
+      _cumulate(false, true) if nearest.mean_cumn.nil?
+
+      nearest.cumn += n
+      nearest.mean_cumn += n / 2.0
+      nearest.n += n
+
+      nil
+    end
+
+    # rubocop:disable Metrics/PerceivedComplexity, Metrics/CyclomaticComplexity
+    def _cumulate(exact = false, force = false)
+      unless force
+        factor = if @last_cumulate == 0
+                   Float::INFINITY
+                 else
+                   (@n.to_f / @last_cumulate)
+                 end
+        return if @n == @last_cumulate || (!exact && @cx && @cx > factor)
+      end
+
+      cumn = 0
+      @centroids.each do |_, c|
+        c.mean_cumn = cumn + c.n / 2.0
+        cumn = c.cumn = cumn + c.n
+      end
+      @n = @last_cumulate = cumn
+      nil
+    end
+    # rubocop:enable Metrics/PerceivedComplexity, Metrics/CyclomaticComplexity
+
+    # rubocop:disable Metrics/PerceivedComplexity, Metrics/CyclomaticComplexity
+    # rubocop:disable Metrics/AbcSize
+    def _digest(x, n)
+      # Use 'first' and 'last' instead of min/max because of performance reasons
+      # This works because RBTree is sorted
+      min = @centroids.first
+      max = @centroids.last
+
+      min = min.nil? ? nil : min[1]
+      max = max.nil? ? nil : max[1]
+      nearest = find_nearest(x)
+
+      @n += n
+
+      if nearest && nearest.mean == x
+        _add_weight(nearest, x, n)
+      elsif nearest == min
+        _new_centroid(x, n, 0)
+      elsif nearest == max
+        _new_centroid(x, n, @n)
+      else
+        p = nearest.mean_cumn.to_f / @n
+        max_n = (4 * @n * @delta * p * (1 - p)).floor
+        if max_n - nearest.n >= n
+          _add_weight(nearest, x, n)
+        else
+          _new_centroid(x, n, nearest.cumn)
+        end
+      end
+
+      _cumulate(false)
+
+      # If the number of centroids has grown to a very large size,
+      # it may be due to values being inserted in sorted order.
+      # We combat that by replaying the centroids in random order,
+      # which is what compress! does
+      compress! if @centroids.size > (@k / @delta)
+
+      nil
+    end
+    # rubocop:enable Metrics/PerceivedComplexity, Metrics/CyclomaticComplexity,
+    # rubocop:enable Metrics/AbcSize
+
+    def _new_centroid(x, n, cumn)
+      c = Centroid.new(x, n, cumn)
+      @centroids[x] = c
+      c
+    end
+  end
+  # rubocop:enable Metrics/ClassLength
+end