airbrake-ruby 4.6.0 → 6.2.2

data/lib/airbrake-ruby/tdigest.rb

@@ -24,6 +24,7 @@ module Airbrake
     # @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
@@ -37,14 +38,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 +61,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 +72,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.with_object([]) do |c, arr|
         k = 0
         n = c.n
         while n < 0 || n > 0x7f
@@ -95,7 +97,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)
@@ -129,7 +131,7 @@ module Airbrake
       points = to_a
       reset!
       push_centroid(points.shuffle)
-      _cumulate(true, true)
+      _cumulate(exact: true, force: true)
       nil
     end
 
@@ -138,21 +140,17 @@ module Airbrake
     end
 
     def find_nearest(x)
-      return nil if size == 0
-
-      ceil  = @centroids.upper_bound(x)
-      floor = @centroids.lower_bound(x)
+      return if size == 0
 
-      return floor[1] if ceil.nil?
-      return ceil[1]  if floor.nil?
+      upper_key, upper = @centroids.upper_bound(x)
+      lower_key, lower = @centroids.lower_bound(x)
+      return lower unless upper_key
+      return upper unless lower_key
 
-      ceil_key  = ceil[0]
-      floor_key = floor[0]
-
-      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
 
@@ -178,7 +176,7 @@ module Airbrake
         elsif item > max[1].mean
           1.0
         else
-          _cumulate(true)
+          _cumulate(exact: true)
           bound = bound_mean(item)
           lower, upper = bound
           mean_cumn = lower.mean_cumn
@@ -186,7 +184,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 +201,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
+          _cumulate(exact: true)
+          h = @size * item
           lower, upper = bound_mean_cumn(h)
           if lower.nil? && upper.nil?
             nil
@@ -237,17 +236,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
@@ -262,7 +256,7 @@ module Airbrake
         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}")
+        means = bytes[start_idx..(start_idx + (4 * size))].unpack("g#{size}")
         # Decode delta encoding of means
         x = 0
         means.map! do |m|
@@ -270,7 +264,7 @@ module Airbrake
           x = m
           m
         end
-        counts_bytes = bytes[(start_idx + 4 * size)..-1].unpack('C*')
+        counts_bytes = bytes[(start_idx + (4 * size))..-1].unpack('C*')
         counts = []
         # Decode variable length integer bytes
         size.times do
@@ -279,6 +273,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,35 +302,35 @@ 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(exact: false, force: 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
-    def _cumulate(exact = false, force = false)
+    def _cumulate(exact: false, force: false)
       unless force
         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|
-        c.mean_cumn = cumn + c.n / 2.0
+      @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,32 +340,29 @@ 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
 
-      _cumulate(false)
+      _cumulate(exact: false)
 
       # If the number of centroids has grown to a very large size,
       # it may be due to values being inserted in sorted order.
@@ -382,12 +374,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

data/lib/airbrake-ruby/thread_pool.rb

@@ -0,0 +1,139 @@
+module Airbrake
+  # ThreadPool implements a simple thread pool that can configure the number of
+  # worker threads and the size of the queue to process.
+  #
+  # @example
+  #   # Initialize a new thread pool with 5 workers and a queue size of 100. Set
+  #   # the block to be run concurrently.
+  #   thread_pool = ThreadPool.new(
+  #     name: 'performance-notifier',
+  #     worker_size: 5,
+  #     queue_size: 100,
+  #     block: proc { |message| print "ECHO: #{message}..."}
+  #   )
+  #
+  #   # Send work.
+  #   10.times { |i| thread_pool << i }
+  #   #=> ECHO: 0...ECHO: 1...ECHO: 2...
+  #
+  # @api private
+  # @since v4.6.1
+  class ThreadPool
+    include Loggable
+
+    # @return [ThreadGroup] the list of workers
+    # @note This is exposed for eaiser unit testing
+    attr_reader :workers
+
+    def initialize(worker_size:, queue_size:, block:, name: nil)
+      @name = name
+      @worker_size = worker_size
+      @queue_size = queue_size
+      @block = block
+
+      @queue = SizedQueue.new(queue_size)
+      @workers = ThreadGroup.new
+      @mutex = Mutex.new
+      @pid = nil
+      @closed = false
+
+      has_workers?
+    end
+
+    # Adds a new message to the thread pool. Rejects messages if the queue is at
+    # its capacity.
+    #
+    # @param [Object] message The message that gets passed to the block
+    # @return [Boolean] true if the message was successfully sent to the pool,
+    #   false if the queue is full
+    def <<(message)
+      if backlog >= @queue_size
+        logger.info do
+          "#{LOG_LABEL} ThreadPool has reached its capacity of " \
+          "#{@queue_size} and the following message will not be " \
+          "processed: #{message.inspect}"
+        end
+        return false
+      end
+
+      @queue << message
+      true
+    end
+
+    # @return [Integer] how big the queue is at the moment
+    def backlog
+      @queue.size
+    end
+
+    # Checks if a thread pool has any workers. A thread pool doesn't have any
+    # workers only in two cases: when it was closed or when all workers
+    # crashed. An *active* thread pool 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
+    def has_workers?
+      @mutex.synchronize do
+        return false if @closed
+
+        if @pid != Process.pid && @workers.list.empty?
+          @pid = Process.pid
+          @workers = ThreadGroup.new
+          spawn_workers
+        end
+
+        !@closed && @workers.list.any?
+      end
+    end
+
+    # Closes the thread pool making it a no-op (it shut downs all worker
+    # threads). Before closing, waits on all unprocessed tasks to be processed.
+    #
+    # @return [void]
+    # @raise [Airbrake::Error] when invoked more than one time
+    def close
+      threads = @mutex.synchronize do
+        raise Airbrake::Error, 'this thread pool is closed already' if @closed
+
+        unless @queue.empty?
+          msg = "#{LOG_LABEL} waiting to process #{@queue.size} task(s)..."
+          logger.debug("#{msg} (Ctrl-C to abort)")
+        end
+
+        @worker_size.times { @queue << :stop }
+        @closed = true
+        @workers.list.dup
+      end
+
+      threads.each(&:join)
+      logger.debug("#{LOG_LABEL} #{@name} thread pool closed")
+    end
+
+    def closed?
+      @closed
+    end
+
+    def spawn_workers
+      @worker_size.times { @workers.add(spawn_worker) }
+    end
+
+    private
+
+    def spawn_worker
+      Thread.new do
+        while (message = @queue.pop)
+          break if message == :stop
+
+          @block.call(message)
+        end
+      end
+    end
+  end
+end

data/lib/airbrake-ruby/time_truncate.rb

@@ -6,10 +6,10 @@ module Airbrake
   module TimeTruncate
     # Truncate +time+ to floor minute and turn it into an RFC3339 timestamp.
     #
-    # @param [Time] time
+    # @param [Time, Integer, Float] time
     # @return [String]
     def self.utc_truncate_minutes(time)
-      tm = time.getutc
+      tm = Time.at(time).getutc
 
       Time.utc(tm.year, tm.month, tm.day, tm.hour, tm.min).to_datetime.rfc3339
     end

data/lib/airbrake-ruby/timed_trace.rb

@@ -50,9 +50,7 @@ module Airbrake
 
     # @return [Hash<String=>Float>]
     def spans
-      @spans.each_with_object({}) do |(label, benchmark), new_spans|
-        new_spans[label] = benchmark.duration
-      end
+      @spans.transform_values(&:duration)
     end
   end
 end

data/lib/airbrake-ruby/truncator.rb

@@ -12,6 +12,10 @@ module Airbrake
     #   strings with +ENCODING_OPTIONS+
     TEMP_ENCODING = 'utf-16'.freeze
 
+    # @return [Array<Encoding>] encodings that are eligible for fixing invalid
+    #   characters
+    SUPPORTED_ENCODINGS = [Encoding::UTF_8, Encoding::ASCII].freeze
+
     # @return [String] what to append when something is a circular reference
     CIRCULAR = '[Circular]'.freeze
 
@@ -35,6 +39,7 @@ module Airbrake
     def truncate(object, seen = Set.new)
       if seen.include?(object.object_id)
         return CIRCULAR if CIRCULAR_TYPES.any? { |t| object.is_a?(t) }
+
         return object
       end
       truncate_object(object, seen << object.object_id)
@@ -63,6 +68,7 @@ module Airbrake
     def truncate_string(str)
       fixed_str = replace_invalid_characters(str)
       return fixed_str if fixed_str.length <= @max_size
+
       (fixed_str.slice(0, @max_size) + TRUNCATED).freeze
     end
 
@@ -76,6 +82,7 @@ module Airbrake
       truncated_hash = {}
       hash.each_with_index do |(key, val), idx|
         break if idx + 1 > @max_size
+
         truncated_hash[key] = truncate(val, seen)
       end
 
@@ -103,13 +110,12 @@ module Airbrake
     # @return [String] a UTF-8 encoded string
     # @see https://github.com/flori/json/commit/3e158410e81f94dbbc3da6b7b35f4f64983aa4e3
     def replace_invalid_characters(str)
-      encoding = str.encoding
-      utf8_string = (encoding == Encoding::UTF_8 || encoding == Encoding::ASCII)
+      utf8_string = SUPPORTED_ENCODINGS.include?(str.encoding)
       return str if utf8_string && str.valid_encoding?
 
       temp_str = str.dup
-      temp_str.encode!(TEMP_ENCODING, ENCODING_OPTIONS) if utf8_string
-      temp_str.encode!('utf-8', ENCODING_OPTIONS)
+      temp_str.encode!(TEMP_ENCODING, **ENCODING_OPTIONS) if utf8_string
+      temp_str.encode!('utf-8', **ENCODING_OPTIONS)
     end
   end
 end

data/lib/airbrake-ruby/version.rb

@@ -2,5 +2,15 @@
 # More information: http://semver.org/
 module Airbrake
   # @return [String] the library version
-  AIRBRAKE_RUBY_VERSION = '4.6.0'.freeze
+  # @api public
+  AIRBRAKE_RUBY_VERSION = '6.2.2'.freeze
+
+  # @return [Hash{Symbol=>String}] the information about the notifier library
+  # @since v5.0.0
+  # @api public
+  NOTIFIER_INFO = {
+    name: 'airbrake-ruby'.freeze,
+    version: Airbrake::AIRBRAKE_RUBY_VERSION,
+    url: 'https://github.com/airbrake/airbrake-ruby'.freeze,
+  }.freeze
 end