airbrake-ruby 4.1.0 → 5.0.0

data/lib/airbrake-ruby/remote_settings.rb

@@ -0,0 +1,145 @@
+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.
+  #
+  # @example Disable/enable error notifications based on the remote value
+  #   RemoteSettings.poll do |data|
+  #     config.error_notifications = data.error_notifications?
+  #   end
+  #
+  # When {#poll} is called, it will try to load remote settings from disk, so
+  # that it doesn't wait on the result from the API call.
+  #
+  # When {#stop_polling} is called, the current config will be dumped to disk.
+  #
+  # @since 5.0.0
+  # @api private
+  class RemoteSettings
+    include Airbrake::Loggable
+
+    # @return [String] the path to the persistent config
+    CONFIG_DUMP_PATH = File.join(
+      File.expand_path(__dir__),
+      '../../config/config.json',
+    ).freeze
+
+    # @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
+
+    # 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
+      @poll = nil
+    end
+
+    # Polls remote config of the given project in background. Loads local config
+    # first (if exists).
+    #
+    # @return [self]
+    def poll
+      @poll ||= Thread.new do
+        begin
+          load_config
+        rescue StandardError => ex
+          logger.error("#{LOG_LABEL} config loading failed: #{ex}")
+        end
+
+        @block.call(@data)
+
+        loop do
+          @block.call(@data.merge!(fetch_config))
+          sleep(@data.interval)
+        end
+      end
+
+      self
+    end
+
+    # Stops the background poller thread. Dumps current config to disk.
+    #
+    # @return [void]
+    def stop_polling
+      @poll.kill if @poll
+
+      begin
+        dump_config
+      rescue StandardError => ex
+        logger.error("#{LOG_LABEL} config dumping failed: #{ex}")
+      end
+    end
+
+    private
+
+    def fetch_config
+      response = nil
+      begin
+        response = Net::HTTP.get(build_config_uri)
+      rescue StandardError => ex
+        logger.error(ex)
+        return {}
+      end
+
+      # AWS S3 API returns XML when request is not valid. In this case we just
+      # print the returned body and exit the method.
+      if response.start_with?('<?xml ')
+        logger.error(response)
+        return {}
+      end
+
+      json = nil
+      begin
+        json = JSON.parse(response)
+      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 load_config
+      config_dir = File.dirname(CONFIG_DUMP_PATH)
+      Dir.mkdir(config_dir) unless File.directory?(config_dir)
+
+      return unless File.exist?(CONFIG_DUMP_PATH)
+
+      config = File.read(CONFIG_DUMP_PATH)
+      @data.merge!(JSON.parse(config))
+    end
+
+    def dump_config
+      config_dir = File.dirname(CONFIG_DUMP_PATH)
+      Dir.mkdir(config_dir) unless File.directory?(config_dir)
+
+      File.write(CONFIG_DUMP_PATH, JSON.dump(@data.to_h))
+    end
+  end
+end

data/lib/airbrake-ruby/request.rb

@@ -4,21 +4,35 @@ module Airbrake
   # @see Airbrake.notify_request
   # @api public
   # @since v3.2.0
-  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
+      'routes-stats'
     end
 
-    def name
+    def cargo
       'routes'
     end
 
@@ -27,7 +41,7 @@ module Airbrake
         '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

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

@@ -9,48 +9,58 @@ 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)
-      }
+      @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 the difference of +end_time+
-    # and +start_time+.
+    # Increments tdigest timings and updates tdigest with given +ms+ value.
     #
-    # @param [Date] start_time
-    # @param [Date] end_time
+    # @param [Float] ms
     # @return [void]
-    def increment(start_time, end_time = nil)
-      end_time ||= Time.new
-
-      self.count += 1
+    def increment_ms(ms)
+      @mutex.synchronize do
+        self.sum += ms
+        self.sumsq += ms * ms
 
-      ms = (end_time - start_time) * 1000
-      self.sum += ms
-      self.sumsq += ms * ms
+        tdigest.push(ms)
+      end
+    end
 
-      tdigest.push(ms)
+    # 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=#{tdigest.size}, sum=#{sum}, sumsq=#{sumsq}>"
     end
+    alias pretty_print inspect
   end
 end

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

data/lib/airbrake-ruby/thread_pool.rb

@@ -0,0 +1,138 @@
+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(
+  #     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:)
+      @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.error(
+          "#{LOG_LABEL} ThreadPool has reached its capacity of " \
+          "#{@queue_size} and the following message will not be " \
+          "processed: #{message.inspect}",
+        )
+        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} thread pool closed")
+    end
+
+    def closed?
+      @closed
+    end
+
+    def spawn_workers
+      @worker_size.times { @workers.add(spawn_worker) }
+      @workers.enclose
+    end
+
+    private
+
+    def spawn_worker
+      Thread.new do
+        while (message = @queue.pop)
+          break if message == :stop
+
+          @block.call(message)
+        end
+      end
+    end
+  end
+end