airbrake-ruby 4.8.0 → 5.2.0

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/request.rb

@@ -4,21 +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
     )
-      @start_time_utc = TimeTruncate.utc_truncate_minutes(start_time)
-      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
@@ -29,18 +36,13 @@ module Airbrake
       'routes'
     end
 
-    def groups
-      {}
-    end
-
     def to_h
       {
         'method' => method,
         'route' => route,
         'statusCode' => status_code,
-        'time' => @start_time_utc
+        'time' => @time_utc,
       }.delete_if { |_key, val| val.nil? }
     end
   end
-  # rubocop:enable Metrics/BlockLength
 end

data/lib/airbrake-ruby/stat.rb

@@ -1,6 +1,5 @@
 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.
@@ -10,54 +9,49 @@ module Airbrake
   #
   # @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

@@ -23,7 +23,7 @@ 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
@@ -47,6 +47,7 @@ module Airbrake
       end
 
       return promise.reject(parsed_resp['error']) if parsed_resp.key?('error')
+
       promise.resolve(parsed_resp)
     end
 
@@ -79,7 +80,7 @@ module Airbrake
       req['Authorization'] = "Bearer #{@config.project_key}"
       req['Content-Type'] = CONTENT_TYPE
       req['User-Agent'] =
-        "#{Airbrake::Notice::NOTIFIER[:name]}/#{Airbrake::AIRBRAKE_RUBY_VERSION}" \
+        "#{Airbrake::NOTIFIER_INFO[:name]}/#{Airbrake::AIRBRAKE_RUBY_VERSION}" \
         " Ruby/#{RUBY_VERSION}"
 
       req

data/lib/airbrake-ruby/tdigest.rb

@@ -37,14 +37,15 @@ module Airbrake
     end
 
     attr_accessor :centroids
+    attr_reader :size
+
     def initialize(delta = 0.01, k = 25, cx = 1.1)
       @delta = delta
       @k = k
       @cx = cx
       @centroids = RBTree.new
-      @nreset = 0
-      @n = 0
-      reset!
+      @size = 0
+      @last_cumulate = 0
     end
 
     def +(other)
@@ -59,8 +60,8 @@ module Airbrake
       # 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 += @centroids.each_value.map(&:mean)
+      output += @centroids.each_value.map(&:n)
       output.pack("NGNG#{size}N#{size}")
     end
 
@@ -70,14 +71,14 @@ module Airbrake
       output = [self.class::SMALL_ENCODING, compression, size]
       x = 0
       # delta encoding allows saving 4-bytes floats
-      mean_arr = @centroids.map do |_, c|
+      mean_arr = @centroids.each_value.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|
+      c_arr = @centroids.each_value.each_with_object([]) do |c, arr|
         k = 0
         n = c.n
         while n < 0 || n > 0x7f
@@ -95,7 +96,7 @@ module Airbrake
     # rubocop:enable Metrics/AbcSize
 
     def as_json(_ = nil)
-      @centroids.map { |_, c| c.as_json }
+      @centroids.each_value.map(&:as_json)
     end
 
     def bound_mean(x)
@@ -138,21 +139,17 @@ module Airbrake
     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?
+      return if size == 0
 
-      ceil_key  = ceil[0]
-      floor_key = floor[0]
+      upper_key, upper = @centroids.upper_bound(x)
+      lower_key, lower = @centroids.lower_bound(x)
+      return lower unless upper_key
+      return upper unless lower_key
 
-      if (floor_key - x).abs < (ceil_key - x).abs
-        floor[1]
+      if (lower_key - x).abs < (upper_key - x).abs
+        lower
       else
-        ceil[1]
+        upper
       end
     end
 
@@ -186,7 +183,7 @@ module Airbrake
             mean_cumn += (item - lower.mean) * (upper.mean_cumn - lower.mean_cumn) \
               / (upper.mean - lower.mean)
           end
-          mean_cumn / @n
+          mean_cumn / @size
         end
       end
       is_array ? x : x.first
@@ -203,11 +200,12 @@ module Airbrake
         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
+          h = @size * item
           lower, upper = bound_mean_cumn(h)
           if lower.nil? && upper.nil?
             nil
@@ -237,17 +235,12 @@ module Airbrake
 
     def reset!
       @centroids.clear
-      @n = 0
-      @nreset += 1
+      @size = 0
       @last_cumulate = 0
     end
 
-    def size
-      @n || 0
-    end
-
     def to_a
-      @centroids.map { |_, c| c }
+      @centroids.each_value.to_a
     end
 
     # rubocop:disable Metrics/PerceivedComplexity, Metrics/MethodLength
@@ -279,6 +272,7 @@ module Airbrake
           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
@@ -307,16 +301,16 @@ module Airbrake
 
     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?
+    def _add_weight(centroid, x, n)
+      unless x == centroid.mean
+        centroid.mean += n * (x - centroid.mean) / (centroid.n + n)
+      end
 
-      nearest.cumn += n
-      nearest.mean_cumn += n / 2.0
-      nearest.n += n
+      _cumulate(false, true) if centroid.mean_cumn.nil?
 
-      nil
+      centroid.cumn += n
+      centroid.mean_cumn += n / 2.0
+      centroid.n += n
     end
 
     # rubocop:disable Metrics/PerceivedComplexity, Metrics/CyclomaticComplexity
@@ -325,17 +319,17 @@ module Airbrake
         factor = if @last_cumulate == 0
                    Float::INFINITY
                  else
-                   (@n.to_f / @last_cumulate)
+                   (@size.to_f / @last_cumulate)
                  end
-        return if @n == @last_cumulate || (!exact && @cx && @cx > factor)
+        return if @size == @last_cumulate || (!exact && @cx && @cx > factor)
       end
 
       cumn = 0
-      @centroids.each do |_, c|
+      @centroids.each_value do |c|
         c.mean_cumn = cumn + c.n / 2.0
         cumn = c.cumn = cumn + c.n
       end
-      @n = @last_cumulate = cumn
+      @size = @last_cumulate = cumn
       nil
     end
     # rubocop:enable Metrics/PerceivedComplexity, Metrics/CyclomaticComplexity
@@ -345,28 +339,25 @@ module Airbrake
     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]
+      min = min.last if (min = @centroids.first)
+      max = max.last if (max = @centroids.last)
       nearest = find_nearest(x)
 
-      @n += n
+      @size += n
 
       if nearest && nearest.mean == x
         _add_weight(nearest, x, n)
       elsif nearest == min
-        _new_centroid(x, n, 0)
+        @centroids[x] = Centroid.new(x, n, 0)
       elsif nearest == max
-        _new_centroid(x, n, @n)
+        @centroids[x] = Centroid.new(x, n, @size)
       else
-        p = nearest.mean_cumn.to_f / @n
-        max_n = (4 * @n * @delta * p * (1 - p)).floor
+        p = nearest.mean_cumn.to_f / @size
+        max_n = (4 * @size * @delta * p * (1 - p)).floor
         if max_n - nearest.n >= n
           _add_weight(nearest, x, n)
         else
-          _new_centroid(x, n, nearest.cumn)
+          @centroids[x] = Centroid.new(x, n, nearest.cumn)
         end
       end
 
@@ -382,12 +373,6 @@ module Airbrake
     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