airbrake-ruby 4.11.1 → 4.13.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6b9d78ba8789ccfa27f139a5ad0fef6b544da9bde4239dfda22cc543493bdb45
-  data.tar.gz: c32c7e64425037221491c64de8e22d548815929ec6e3a0289aad3c74f8ffedc7
+  metadata.gz: 63e544ab7354b30c5a8f4e3e73ba22daf9f27a0e3d4804e3bf015f38b34a6314
+  data.tar.gz: f2d238127b26e3fdfdc1b7848f847760993a87d15182ec7266e42d7db753609c
 SHA512:
-  metadata.gz: 711d058e48af32390e7b92243171014122b5e454cea35afd19ca72e5fe39d04b919f0cbc95dfdf23685a3114cac14430310eb5a0c785c263d85a52ca26bab861
-  data.tar.gz: 300176c0bab2a6ddcb4b3453069be19ef5a477021ca10f68256edabc97c9d0d15b3b4a5659f2676e53071f89229b59c90ac6d0f1016d953342af8d9fc8b27581
+  metadata.gz: 759ab3e188a8c20f2363e6aabdda6634f278b87cf24a67ecaad3998dde0dfe9de856ad8ca44f6a068b22afc2f8dcd7408ab66be6010ec3090cd2b52eef4434d8
+  data.tar.gz: 845c5c487af401362663273c85d56fb924578332a227ba534ced253d954af17ebdade9c6d5346a8e9640fcb4c8583ad068c8c43d0bc85fa7ec41298aff07c978

data/lib/airbrake-ruby.rb

@@ -1,7 +1,6 @@
 require 'net/https'
 require 'logger'
 require 'json'
-require 'thread'
 require 'set'
 require 'socket'
 require 'time'
@@ -84,6 +83,13 @@ module Airbrake
   #  special cases where we need to work around older implementations
   JRUBY = (RUBY_ENGINE == 'jruby')
 
+  # @return [Boolean] true if this Ruby supports safe levels and tainting,
+  #  to guard against using deprecated or unsupported features.
+  HAS_SAFE_LEVEL = (
+    RUBY_ENGINE == 'ruby' &&
+    Gem::Version.new(RUBY_VERSION) < Gem::Version.new('2.7')
+  )
+
   class << self
     # @since v4.2.3
     # @api private
@@ -364,7 +370,7 @@ module Airbrake
     # @since v3.0.0
     # @see Airbrake::PerformanceNotifier#notify
     def notify_request(request_info, stash = {})
-      request = Request.new(request_info)
+      request = Request.new(**request_info)
       request.stash.merge!(stash)
       performance_notifier.notify(request)
     end
@@ -374,7 +380,7 @@ module Airbrake
     # @since v4.10.0
     # @see .notify_request
     def notify_request_sync(request_info, stash = {})
-      request = Request.new(request_info)
+      request = Request.new(**request_info)
       request.stash.merge!(stash)
       performance_notifier.notify_sync(request)
     end
@@ -407,7 +413,7 @@ module Airbrake
     # @since v3.2.0
     # @see Airbrake::PerformanceNotifier#notify
     def notify_query(query_info, stash = {})
-      query = Query.new(query_info)
+      query = Query.new(**query_info)
       query.stash.merge!(stash)
       performance_notifier.notify(query)
     end
@@ -418,7 +424,7 @@ module Airbrake
     # @since v4.10.0
     # @see .notify_query
     def notify_query_sync(query_info, stash = {})
-      query = Query.new(query_info)
+      query = Query.new(**query_info)
       query.stash.merge!(stash)
       performance_notifier.notify_sync(query)
     end
@@ -446,7 +452,7 @@ module Airbrake
     # @return [void]
     # @since v4.2.0
     def notify_performance_breakdown(breakdown_info, stash = {})
-      performance_breakdown = PerformanceBreakdown.new(breakdown_info)
+      performance_breakdown = PerformanceBreakdown.new(**breakdown_info)
       performance_breakdown.stash.merge!(stash)
       performance_notifier.notify(performance_breakdown)
     end
@@ -456,7 +462,7 @@ module Airbrake
     # @since v4.10.0
     # @see .notify_performance_breakdown
     def notify_performance_breakdown_sync(breakdown_info, stash = {})
-      performance_breakdown = PerformanceBreakdown.new(breakdown_info)
+      performance_breakdown = PerformanceBreakdown.new(**breakdown_info)
       performance_breakdown.stash.merge!(stash)
       performance_notifier.notify_sync(performance_breakdown)
     end
@@ -484,7 +490,7 @@ module Airbrake
     # @since v4.9.0
     # @see .notify_queue_sync
     def notify_queue(queue_info, stash = {})
-      queue = Queue.new(queue_info)
+      queue = Queue.new(**queue_info)
       queue.stash.merge!(stash)
       performance_notifier.notify(queue)
     end
@@ -493,7 +499,7 @@ module Airbrake
     # @since v4.10.0
     # @see .notify_queue
     def notify_queue_sync(queue_info, stash = {})
-      queue = Queue.new(queue_info)
+      queue = Queue.new(**queue_info)
       queue.stash.merge!(stash)
       performance_notifier.notify_sync(queue)
     end
@@ -575,6 +581,7 @@ module Airbrake
         notice_notifier.add_filter(whitelist)
       end
 
+      return if configured?
       return unless config.root_directory
 
       [

data/lib/airbrake-ruby/async_sender.rb

@@ -7,12 +7,6 @@ module Airbrake
   class AsyncSender
     include Loggable
 
-    # @return [String]
-    WILL_NOT_DELIVER_MSG =
-      "%<log_label>s AsyncSender has reached its capacity of %<capacity>s " \
-      "and the following notice will not be delivered " \
-      "Error: %<type>s - %<message>s\nBacktrace: %<backtrace>s\n".freeze
-
     def initialize(method = :post)
       @config = Airbrake::Config.instance
       @method = method
@@ -20,12 +14,13 @@ module Airbrake
 
     # Asynchronously sends a notice to Airbrake.
     #
-    # @param [Airbrake::Notice] notice A notice that was generated by the
-    #   library
+    # @param [Hash] payload Whatever needs to be sent
     # @return [Airbrake::Promise]
-    def send(notice, promise, endpoint = @config.endpoint)
-      unless thread_pool << [notice, promise, endpoint]
-        return will_not_deliver(notice, promise)
+    def send(payload, promise, endpoint = @config.endpoint)
+      unless thread_pool << [payload, promise, endpoint]
+        return promise.reject(
+          "AsyncSender has reached its capacity of #{@config.queue_size}",
+        )
       end
 
       promise
@@ -58,23 +53,5 @@ module Airbrake
         )
       end
     end
-
-    def will_not_deliver(notice, promise)
-      error = notice[:errors].first
-
-      logger.error(
-        format(
-          WILL_NOT_DELIVER_MSG,
-          log_label: LOG_LABEL,
-          capacity: @config.queue_size,
-          type: error[:type],
-          message: error[:message],
-          backtrace: error[:backtrace].map do |line|
-            "#{line[:file]}:#{line[:line]} in `#{line[:function]}'"
-          end.join("\n"),
-        ),
-      )
-      promise.reject("AsyncSender has reached its capacity of #{@config.queue_size}")
-    end
   end
 end

data/lib/airbrake-ruby/config.rb

@@ -101,6 +101,12 @@ module Airbrake
     # @since v4.6.0
     attr_accessor :query_stats
 
+    # @return [Boolean] true if the library should send job/queue/worker stats
+    #   to Airbrake, false otherwise
+    # @api public
+    # @since v4.12.0
+    attr_accessor :job_stats
+
     class << self
       # @return [Config]
       attr_writer :instance
@@ -113,12 +119,13 @@ module Airbrake
 
     # @param [Hash{Symbol=>Object}] user_config the hash to be used to build the
     #   config
+    # rubocop:disable Metrics/AbcSize
     def initialize(user_config = {})
       self.proxy = {}
       self.queue_size = 100
       self.workers = 1
       self.code_hunks = true
-      self.logger = ::Logger.new(File::NULL)
+      self.logger = ::Logger.new(File::NULL).tap { |l| l.level = Logger::WARN }
       self.project_id = user_config[:project_id]
       self.project_key = user_config[:project_key]
       self.host = 'https://api.airbrake.io'
@@ -139,9 +146,11 @@ module Airbrake
       self.performance_stats = true
       self.performance_stats_flush_period = 15
       self.query_stats = true
+      self.job_stats = true
 
       merge(user_config)
     end
+    # rubocop:enable Metrics/AbcSize
 
     # The full URL to the Airbrake Notice API. Based on the +:host+ option.
     # @return [URI] the endpoint address
@@ -213,6 +222,8 @@ module Airbrake
         promise.reject("The Performance Stats feature is disabled")
       elsif resource.is_a?(Airbrake::Query) && !query_stats
         promise.reject("The Query Stats feature is disabled")
+      elsif resource.is_a?(Airbrake::Queue) && !job_stats
+        promise.reject("The Job Stats feature is disabled")
       else
         promise
       end

data/lib/airbrake-ruby/filters/keys_filter.rb

@@ -24,7 +24,18 @@ module Airbrake
 
       # @return [Array<Symbol>] parts of a Notice's *context* payload that can
       #   be modified by blacklist/whitelist filters
-      FILTERABLE_CONTEXT_KEYS = %i[user headers].freeze
+      FILTERABLE_CONTEXT_KEYS = %i[
+        user
+
+        # Provided by Airbrake::Rack::HttpHeadersFilter
+        headers
+        referer
+        httpMethod
+
+        # Provided by Airbrake::Rack::ContextFilter
+        userAddr
+        userAgent
+      ].freeze
 
       include Loggable
 

data/lib/airbrake-ruby/filters/thread_filter.rb

@@ -72,7 +72,7 @@ module Airbrake
         thread_info[:group] = th.group.list.map(&:inspect)
         thread_info[:priority] = th.priority
 
-        thread_info[:safe_level] = th.safe_level unless Airbrake::JRUBY
+        thread_info[:safe_level] = th.safe_level if Airbrake::HAS_SAFE_LEVEL
       end
 
       def sanitize_value(value)

data/lib/airbrake-ruby/loggable.rb

@@ -22,7 +22,7 @@ module Airbrake
 
       # @return [Logger]
       def instance
-        @instance ||= ::Logger.new(File::NULL)
+        @instance ||= ::Logger.new(File::NULL).tap { |l| l.level = ::Logger::WARN }
       end
     end
 

data/lib/airbrake-ruby/monotonic_time.rb

@@ -16,6 +16,11 @@ module Airbrake
         time_in_nanoseconds / (10.0**6)
       end
 
+      # @return [Integer] current monotonic time in seconds
+      def time_in_s
+        time_in_nanoseconds / (10.0**9)
+      end
+
       private
 
       if defined?(Process::CLOCK_MONOTONIC)

data/lib/airbrake-ruby/notice.rb

@@ -76,7 +76,7 @@ module Airbrake
     #
     # @return [Hash{String=>String}, nil]
     # @api private
-    def to_json
+    def to_json(*_args)
       loop do
         begin
           json = @payload.to_json

data/lib/airbrake-ruby/notice_notifier.rb

@@ -9,7 +9,7 @@ module Airbrake
     # @return [Array<Class>] filters to be executed first
     DEFAULT_FILTERS = [
       Airbrake::Filters::SystemExitFilter,
-      Airbrake::Filters::GemRootFilter
+      Airbrake::Filters::GemRootFilter,
 
       # Optional filters (must be included by users):
       # Airbrake::Filters::ThreadFilter

data/lib/airbrake-ruby/performance_breakdown.rb

@@ -5,16 +5,16 @@ module Airbrake
   # @see Airbrake.notify_breakdown
   # @api public
   # @since v4.2.0
-  # rubocop:disable Metrics/BlockLength, Metrics/ParameterLists
-  PerformanceBreakdown = Struct.new(
-    :method, :route, :response_type, :groups, :start_time, :end_time, :timing,
-    :time
-  ) do
+  # rubocop:disable Metrics/ParameterLists
+  class PerformanceBreakdown
     include HashKeyable
     include Ignorable
     include Stashable
     include Mergeable
 
+    attr_accessor :method, :route, :response_type, :groups, :start_time,
+                  :end_time, :timing, :time
+
     def initialize(
       method:,
       route:,
@@ -26,9 +26,14 @@ module Airbrake
       time: Time.now
     )
       @time_utc = TimeTruncate.utc_truncate_minutes(time)
-      super(
-        method, route, response_type, groups, start_time, end_time, timing, time
-      )
+      @method = method
+      @route = route
+      @response_type = response_type
+      @groups = groups
+      @start_time = start_time
+      @end_time = end_time
+      @timing = timing
+      @time = time
     end
 
     def destination
@@ -48,5 +53,5 @@ module Airbrake
       }.delete_if { |_key, val| val.nil? }
     end
   end
-  # rubocop:enable Metrics/BlockLength, Metrics/ParameterLists
+  # rubocop:enable Metrics/ParameterLists
 end

data/lib/airbrake-ruby/performance_notifier.rb

@@ -14,18 +14,20 @@ module Airbrake
       @flush_period = Airbrake::Config.instance.performance_stats_flush_period
       @async_sender = AsyncSender.new(:put)
       @sync_sender = SyncSender.new(:put)
-      @payload = {}
       @schedule_flush = nil
-      @mutex = Mutex.new
       @filter_chain = FilterChain.new
-      @waiting = false
+
+      @payload = {}.extend(MonitorMixin)
+      @has_payload = @payload.new_cond
     end
 
     # @param [Hash] resource
     # @see Airbrake.notify_query
     # @see Airbrake.notify_request
     def notify(resource)
-      send_resource(resource, sync: false)
+      @payload.synchronize do
+        send_resource(resource, sync: false)
+      end
     end
 
     # @param [Hash] resource
@@ -46,7 +48,7 @@ module Airbrake
     end
 
     def close
-      @mutex.synchronize do
+      @payload.synchronize do
         @schedule_flush.kill if @schedule_flush
         @async_sender.close
         logger.debug("#{LOG_LABEL} performance notifier closed")
@@ -55,6 +57,46 @@ module Airbrake
 
     private
 
+    def schedule_flush
+      @schedule_flush ||= Thread.new do
+        loop do
+          @payload.synchronize do
+            @last_flush_time ||= MonotonicTime.time_in_s
+
+            while (MonotonicTime.time_in_s - @last_flush_time) < @flush_period
+              @has_payload.wait(@flush_period)
+            end
+
+            if @payload.none?
+              @last_flush_time = nil
+              next
+            end
+
+            send(@async_sender, @payload, Airbrake::Promise.new)
+            @payload.clear
+          end
+        end
+      end
+    end
+
+    def send_resource(resource, sync:)
+      promise = check_configuration(resource)
+      return promise if promise.rejected?
+
+      @filter_chain.refine(resource)
+      if resource.ignored?
+        return Promise.new.reject("#{resource.class} was ignored by a filter")
+      end
+
+      update_payload(resource)
+      if sync || @flush_period == 0
+        send(@sync_sender, @payload, promise)
+      else
+        @has_payload.signal
+        schedule_flush
+      end
+    end
+
     def update_payload(resource)
       if (total_stat = @payload[resource])
         @payload.key(total_stat).merge(resource)
@@ -83,61 +125,6 @@ module Airbrake
       end
     end
 
-    def schedule_flush
-      return if @payload.empty?
-
-      if @schedule_flush && @schedule_flush.status == 'sleep' && @waiting
-        begin
-          @schedule_flush.run
-        rescue ThreadError => exception
-          logger.error("#{LOG_LABEL}: error occurred while flushing: #{exception}")
-        end
-      end
-
-      @schedule_flush ||= spawn_timer
-    end
-
-    def spawn_timer
-      Thread.new do
-        loop do
-          if @payload.none?
-            @waiting = true
-            Thread.stop
-            @waiting = false
-          end
-
-          sleep(@flush_period)
-
-          payload = nil
-          @mutex.synchronize do
-            payload = @payload
-            @payload = {}
-          end
-
-          send(@async_sender, payload, Airbrake::Promise.new)
-        end
-      end
-    end
-
-    def send_resource(resource, sync:)
-      promise = check_configuration(resource)
-      return promise if promise.rejected?
-
-      @filter_chain.refine(resource)
-      if resource.ignored?
-        return Promise.new.reject("#{resource.class} was ignored by a filter")
-      end
-
-      @mutex.synchronize do
-        update_payload(resource)
-        if sync || @flush_period == 0
-          send(@sync_sender, @payload, promise)
-        else
-          schedule_flush
-        end
-      end
-    end
-
     def check_configuration(resource)
       promise = @config.check_configuration
       return promise if promise.rejected?
@@ -153,16 +140,17 @@ module Airbrake
     end
 
     def send(sender, payload, promise)
-      signature = "#{self.class.name}##{__method__}"
-      raise "#{signature}: payload (#{payload}) cannot be empty. Race?" if payload.none?
-
-      logger.debug { "#{LOG_LABEL} #{signature}: #{payload}" }
+      raise "payload cannot be empty. Race?" if payload.none?
 
       with_grouped_payload(payload) do |resource_hash, destination|
         url = URI.join(
           @config.host,
           "api/v5/projects/#{@config.project_id}/#{destination}",
         )
+
+        logger.debug do
+          "#{LOG_LABEL} #{self.class.name}##{__method__}: #{resource_hash}"
+        end
         sender.send(resource_hash, promise, url)
       end
 

data/lib/airbrake-ruby/query.rb

@@ -4,17 +4,17 @@ module Airbrake
   # @see Airbrake.notify_query
   # @api public
   # @since v3.2.0
-  # rubocop:disable Metrics/ParameterLists, Metrics/BlockLength
-  Query = Struct.new(
-    :method, :route, :query, :func, :file, :line, :start_time, :end_time,
-    :timing, :time
-  ) do
+  # rubocop:disable Metrics/ParameterLists
+  class Query
     include HashKeyable
     include Ignorable
     include Stashable
     include Mergeable
     include Grouppable
 
+    attr_accessor :method, :route, :query, :func, :file, :line, :start_time,
+                  :end_time, :timing, :time
+
     def initialize(
       method:,
       route:,
@@ -28,10 +28,16 @@ module Airbrake
       time: Time.now
     )
       @time_utc = TimeTruncate.utc_truncate_minutes(time)
-      super(
-        method, route, query, func, file, line, start_time, end_time, timing,
-        time
-      )
+      @method = method
+      @route = route
+      @query = query
+      @func = func
+      @file = file
+      @line = line
+      @start_time = start_time
+      @end_time = end_time
+      @timing = timing
+      @time = time
     end
 
     def destination
@@ -53,6 +59,6 @@ module Airbrake
         'line' => line,
       }.delete_if { |_key, val| val.nil? }
     end
-    # rubocop:enable Metrics/ParameterLists, Metrics/BlockLength
+    # rubocop:enable Metrics/ParameterLists
   end
 end

data/lib/airbrake-ruby/queue.rb

@@ -4,14 +4,15 @@ module Airbrake
   # @see Airbrake.notify_queue
   # @api public
   # @since v4.9.0
-  # rubocop:disable Metrics/BlockLength, Metrics/ParameterLists
-  Queue = Struct.new(
-    :queue, :error_count, :groups, :start_time, :end_time, :timing, :time
-  ) do
+  # rubocop:disable Metrics/ParameterLists
+  class Queue
     include HashKeyable
     include Ignorable
     include Stashable
 
+    attr_accessor :queue, :error_count, :groups, :start_time, :end_time,
+                  :timing, :time
+
     def initialize(
       queue:,
       error_count:,
@@ -22,7 +23,13 @@ module Airbrake
       time: Time.now
     )
       @time_utc = TimeTruncate.utc_truncate_minutes(time)
-      super(queue, error_count, groups, start_time, end_time, timing, time)
+      @queue = queue
+      @error_count = error_count
+      @groups = groups
+      @start_time = start_time
+      @end_time = end_time
+      @timing = timing
+      @time = time
     end
 
     def destination
@@ -51,6 +58,15 @@ module Airbrake
     def merge(other)
       self.error_count += other.error_count
     end
+
+    # Queues don't have routes, but we want to define this to make sure our
+    # filter API is consistent (other models define this property)
+    #
+    # @return [String] empty route
+    # @see https://github.com/airbrake/airbrake-ruby/pull/537
+    def route
+      ''
+    end
   end
-  # rubocop:enable Metrics/BlockLength, Metrics/ParameterLists
+  # rubocop:enable Metrics/ParameterLists
 end

data/lib/airbrake-ruby/request.rb

@@ -4,16 +4,17 @@ module Airbrake
   # @see Airbrake.notify_request
   # @api public
   # @since v3.2.0
-  # rubocop:disable Metrics/BlockLength, Metrics/ParameterLists
-  Request = Struct.new(
-    :method, :route, :status_code, :start_time, :end_time, :timing, :time
-  ) do
+  # rubocop:disable Metrics/ParameterLists
+  class Request
     include HashKeyable
     include Ignorable
     include Stashable
     include Mergeable
     include Grouppable
 
+    attr_accessor :method, :route, :status_code, :start_time, :end_time,
+                  :timing, :time
+
     def initialize(
       method:,
       route:,
@@ -24,7 +25,13 @@ module Airbrake
       time: Time.now
     )
       @time_utc = TimeTruncate.utc_truncate_minutes(time)
-      super(method, route, status_code, start_time, end_time, timing, time)
+      @method = method
+      @route = route
+      @status_code = status_code
+      @start_time = start_time
+      @end_time = end_time
+      @timing = timing
+      @time = time
     end
 
     def destination
@@ -44,5 +51,5 @@ module Airbrake
       }.delete_if { |_key, val| val.nil? }
     end
   end
-  # rubocop:enable Metrics/BlockLength, Metrics/ParameterLists
+  # rubocop:enable Metrics/ParameterLists
 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.
@@ -14,30 +13,36 @@ module Airbrake
   #   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 the difference between
+    # +end_time+ and +start_time+.
     #
     # @param [Date] start_time
     # @param [Date] end_time
@@ -47,17 +52,17 @@ module Airbrake
       increment_ms((end_time - start_time) * 1000)
     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 +70,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/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 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
 
@@ -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
@@ -207,7 +204,7 @@ module Airbrake
           nil
         else
           _cumulate(true)
-          h = @n * item
+          h = @size * item
           lower, upper = bound_mean_cumn(h)
           if lower.nil? && upper.nil?
             nil
@@ -237,17 +234,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
@@ -307,16 +299,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 +317,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 +337,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 +371,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

@@ -45,7 +45,15 @@ module Airbrake
     # @return [Boolean] true if the message was successfully sent to the pool,
     #   false if the queue is full
     def <<(message)
-      return false if backlog >= @queue_size
+      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

data/lib/airbrake-ruby/truncator.rb

@@ -108,8 +108,8 @@ module Airbrake
       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,5 @@
 # More information: http://semver.org/
 module Airbrake
   # @return [String] the library version
-  AIRBRAKE_RUBY_VERSION = '4.11.1'.freeze
+  AIRBRAKE_RUBY_VERSION = '4.13.3'.freeze
 end

data/spec/airbrake_spec.rb

@@ -75,6 +75,16 @@ RSpec.describe Airbrake do
         described_class.configure {}
         expect(described_class.deploy_notifier).to eql(deploy_notifier)
       end
+
+      it "doesn't append the same notice notifier filters over and over" do
+        described_class.configure do |c|
+          c.project_id = 1
+          c.project_key = '2'
+        end
+
+        expect(described_class.notice_notifier).not_to receive(:add_filter)
+        10.times { described_class.configure {} }
+      end
     end
 
     context "when blacklist_keys gets configured" do

data/spec/async_sender_spec.rb

@@ -58,15 +58,6 @@ RSpec.describe Airbrake::AsyncSender do
           'error' => "AsyncSender has reached its capacity of 1",
         )
       end
-
-      it "logs discarded notice" do
-        expect(Airbrake::Loggable.instance).to receive(:error).with(
-          /reached its capacity/,
-        ).at_least(:once)
-
-        15.times { subject.send(notice, Airbrake::Promise.new) }
-        subject.close
-      end
     end
   end
 end

data/spec/config_spec.rb

@@ -22,6 +22,7 @@ RSpec.describe Airbrake::Config do
   its(:performance_stats) { is_expected.to eq(true) }
   its(:performance_stats_flush_period) { is_expected.to eq(15) }
   its(:query_stats) { is_expected.to eq(true) }
+  its(:job_stats) { is_expected.to eq(true) }
 
   describe "#new" do
     context "when user config is passed" do
@@ -146,5 +147,26 @@ RSpec.describe Airbrake::Config do
         )
       end
     end
+
+    context "when job stats are disabled" do
+      before { subject.job_stats = false }
+
+      let(:resource) do
+        Airbrake::Queue.new(queue: 'foo_queue', error_count: 0, timing: 1)
+      end
+
+      it "returns a rejected promise" do
+        promise = subject.check_performance_options(resource)
+        expect(promise.value).to eq(
+          'error' => "The Job Stats feature is disabled",
+        )
+      end
+    end
+  end
+
+  describe "#logger" do
+    it "sets logger level to Logger::WARN" do
+      expect(subject.logger.level).to eq(Logger::WARN)
+    end
   end
 end

data/spec/filters/thread_filter_spec.rb

@@ -258,7 +258,9 @@ RSpec.describe Airbrake::Filters::ThreadFilter do
     expect(notice[:params][:thread][:priority]).to eq(0)
   end
 
-  it "appends safe_level", skip: Airbrake::JRUBY do
+  it "appends safe_level", skip: (
+    "Not supported on this version of Ruby." unless Airbrake::HAS_SAFE_LEVEL
+  ) do
     subject.call(notice)
     expect(notice[:params][:thread][:safe_level]).to eq(0)
   end

data/spec/loggable_spec.rb

@@ -0,0 +1,17 @@
+RSpec.describe Airbrake::Loggable do
+  describe ".instance" do
+    it "returns a logger" do
+      expect(described_class.instance).to be_a(Logger)
+    end
+  end
+
+  describe "#logger" do
+    let(:subject) do
+      Class.new { include Airbrake::Loggable }.new
+    end
+
+    it "returns a logger that has Logger::WARN severity" do
+      expect(subject.logger.level).to eq(Logger::WARN)
+    end
+  end
+end

data/spec/monotonic_time_spec.rb

@@ -9,4 +9,15 @@ RSpec.describe Airbrake::MonotonicTime do
       expect(subject.time_in_ms).to be > old_time
     end
   end
+
+  describe ".time_in_s" do
+    it "returns monotonic time in seconds" do
+      expect(subject.time_in_s).to be_a(Float)
+    end
+
+    it "always returns time in the future" do
+      old_time = subject.time_in_s
+      expect(subject.time_in_s).to be > old_time
+    end
+  end
 end

data/spec/performance_notifier_spec.rb

@@ -16,6 +16,7 @@ RSpec.describe Airbrake::PerformanceNotifier do
       performance_stats: true,
       performance_stats_flush_period: 0,
       query_stats: true,
+      job_stats: true,
     )
   end
 

data/spec/queue_spec.rb

@@ -18,4 +18,13 @@ RSpec.describe Airbrake::Queue do
       expect(queue.end_time).to eq(time + 1)
     end
   end
+
+  describe "#route" do
+    it "always returns an empty route" do
+      queue = described_class.new(
+        queue: 'a', error_count: 0, start_time: Time.now,
+      )
+      expect(queue.route).to be_empty
+    end
+  end
 end

data/spec/stat_spec.rb

@@ -22,7 +22,6 @@ RSpec.describe Airbrake::Stat do
   describe "#increment_ms" do
     before { subject.increment_ms(1000) }
 
-    its(:count) { is_expected.to eq(1) }
     its(:sum) { is_expected.to eq(1000) }
     its(:sumsq) { is_expected.to eq(1000000) }
 

data/spec/thread_pool_spec.rb

@@ -51,6 +51,15 @@ RSpec.describe Airbrake::ThreadPool do
 
         expect(tasks.size).to be_zero
       end
+
+      it "logs discarded tasks" do
+        expect(Airbrake::Loggable.instance).to receive(:error).with(
+          /reached its capacity/,
+        ).exactly(15).times
+
+        15.times { subject << 1 }
+        subject.close
+      end
     end
   end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: airbrake-ruby
 version: !ruby/object:Gem::Version
-  version: 4.11.1
+  version: 4.13.3
 platform: ruby
 authors:
 - Airbrake Technologies, Inc.
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-12-20 00:00:00.000000000 Z
+date: 2020-03-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rbtree3
@@ -120,6 +120,7 @@ files:
 - spec/helpers.rb
 - spec/ignorable_spec.rb
 - spec/inspectable_spec.rb
+- spec/loggable_spec.rb
 - spec/monotonic_time_spec.rb
 - spec/nested_exception_spec.rb
 - spec/notice_notifier/options_spec.rb
@@ -189,6 +190,7 @@ test_files:
 - spec/tdigest_spec.rb
 - spec/async_sender_spec.rb
 - spec/stat_spec.rb
+- spec/loggable_spec.rb
 - spec/backtrace_spec.rb
 - spec/notice_notifier_spec.rb
 - spec/time_truncate_spec.rb