airbrake-ruby 4.6.0 → 6.2.2

data/lib/airbrake-ruby/inspectable.rb

@@ -21,7 +21,7 @@ module Airbrake
         project_id: @config.project_id,
         project_key: @config.project_key,
         host: @config.host,
-        filter_chain: @filter_chain.inspect
+        filter_chain: @filter_chain.inspect,
       )
     end
 
@@ -30,7 +30,7 @@ module Airbrake
       q.text("#<#{self.class}:0x#{(object_id << 1).to_s(16).rjust(16, '0')} ")
       q.text(
         "project_id=\"#{@config.project_id}\" project_key=\"#{@config.project_key}\" " \
-        "host=\"#{@config.host}\" filter_chain="
+        "host=\"#{@config.host}\" filter_chain=",
       )
       q.pp(@filter_chain)
       q.text('>')

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

@@ -0,0 +1,12 @@
+module Airbrake
+  # Mergeable adds the `#merge` method, so that we don't need to define it in
+  # all of performance models every time we add a model.
+  #
+  # @since v4.9.0
+  # @api private
+  module Mergeable
+    def merge(_other)
+      nil
+    end
+  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)
@@ -34,7 +39,7 @@ module Airbrake
 
         def time_in_nanoseconds
           time = Time.now
-          time.to_i * (10**9) + time.nsec
+          (time.to_i * (10**9)) + time.nsec
         end
 
       end

data/lib/airbrake-ruby/nested_exception.rb

@@ -9,6 +9,18 @@ module Airbrake
     #   can unwrap. Exceptions that have a longer cause chain will be ignored
     MAX_NESTED_EXCEPTIONS = 3
 
+    # On Ruby 3.1+, the error highlighting gem can produce messages that can
+    # span multiple lines. We don't display multiline error messages in the
+    # title of the notice in the Airbrake dashboard. Therefore, we want to strip
+    # out the higlighting part so that the errors look consistent. The full
+    # message with the exception will be attached to the notice body.
+    #
+    # @return [String]
+    RUBY_31_ERROR_HIGHLIGHTING_DIVIDER = "\n\n".freeze
+
+    # @return [Hash] the options for +String#encode+
+    ENCODING_OPTIONS = { invalid: :replace, undef: :replace }.freeze
+
     def initialize(exception)
       @exception = exception
     end
@@ -16,7 +28,7 @@ module Airbrake
     def as_json
       unwind_exceptions.map do |exception|
         { type: exception.class.name,
-          message: exception.message,
+          message: message(exception),
           backtrace: Backtrace.parse(exception) }
       end
     end
@@ -34,5 +46,14 @@ module Airbrake
 
       exception_list
     end
+
+    def message(exception)
+      return unless (msg = exception.message)
+
+      msg
+        .encode(Encoding::UTF_8, **ENCODING_OPTIONS)
+        .split(RUBY_31_ERROR_HIGHLIGHTING_DIVIDER)
+        .first
+    end
   end
 end

data/lib/airbrake-ruby/notice.rb

@@ -4,19 +4,12 @@ module Airbrake
   #
   # @since v1.0.0
   class Notice
-    # @return [Hash{Symbol=>String}] the information about the notifier library
-    NOTIFIER = {
-      name: 'airbrake-ruby'.freeze,
-      version: Airbrake::AIRBRAKE_RUBY_VERSION,
-      url: 'https://github.com/airbrake/airbrake-ruby'.freeze
-    }.freeze
-
     # @return [Hash{Symbol=>String,Hash}] the information to be displayed in the
     #   Context tab in the dashboard
     CONTEXT = {
       os: RUBY_PLATFORM,
       language: "#{RUBY_ENGINE}/#{RUBY_VERSION}".freeze,
-      notifier: NOTIFIER
+      notifier: Airbrake::NOTIFIER_INFO,
     }.freeze
 
     # @return [Integer] the maxium size of the JSON payload in bytes
@@ -32,7 +25,7 @@ module Airbrake
       IOError,
       NotImplementedError,
       JSON::GeneratorError,
-      Encoding::UndefinedConversionError
+      Encoding::UndefinedConversionError,
     ].freeze
 
     # @return [Array<Symbol>] the list of keys that can be be overwritten with
@@ -56,16 +49,17 @@ module Airbrake
     # @api private
     def initialize(exception, params = {})
       @config = Airbrake::Config.instance
+      @truncator = Airbrake::Truncator.new(PAYLOAD_MAX_SIZE)
+
       @payload = {
         errors: NestedException.new(exception).as_json,
-        context: context,
+        context: context(exception),
         environment: {
-          program_name: $PROGRAM_NAME
+          program_name: $PROGRAM_NAME,
         },
         session: {},
-        params: params
+        params: params,
       }
-      @truncator = Airbrake::Truncator.new(PAYLOAD_MAX_SIZE)
 
       stash[:exception] = exception
     end
@@ -76,7 +70,7 @@ module Airbrake
     #
     # @return [Hash{String=>String}, nil]
     # @api private
-    def to_json
+    def to_json(*_args)
       loop do
         begin
           json = @payload.to_json
@@ -125,7 +119,7 @@ module Airbrake
 
     private
 
-    def context
+    def context(exception)
       {
         version: @config.app_version,
         versions: @config.versions,
@@ -138,7 +132,8 @@ module Airbrake
         # Make sure we always send hostname.
         hostname: HOSTNAME,
 
-        severity: DEFAULT_SEVERITY
+        severity: DEFAULT_SEVERITY,
+        error_message: @truncator.truncate(exception.message),
       }.merge(CONTEXT).delete_if { |_key, val| val.nil? || val.empty? }
     end
 
@@ -152,7 +147,7 @@ module Airbrake
         logger.error(
           "#{LOG_LABEL} truncation failed. File an issue at " \
           "https://github.com/airbrake/airbrake-ruby " \
-          "and attach the following payload: #{@payload}"
+          "and attach the following payload: #{@payload}",
         )
       end
 

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
@@ -20,14 +20,13 @@ module Airbrake
 
     def initialize
       @config = Airbrake::Config.instance
-      @context = {}
       @filter_chain = FilterChain.new
-      @async_sender = AsyncSender.new
+      @async_sender = AsyncSender.new(:post, self.class.name)
       @sync_sender = SyncSender.new
 
       DEFAULT_FILTERS.each { |filter| add_filter(filter.new) }
 
-      add_filter(Airbrake::Filters::ContextFilter.new(@context))
+      add_filter(Airbrake::Filters::ContextFilter.new)
       add_filter(Airbrake::Filters::ExceptionAttributesFilter.new)
     end
 
@@ -55,7 +54,8 @@ module Airbrake
     def build_notice(exception, params = {})
       if @async_sender.closed?
         raise Airbrake::Error,
-              "attempted to build #{exception} with closed Airbrake instance"
+              "Airbrake is closed; can't build exception: " \
+              "#{exception.class}: #{exception}"
       end
 
       if exception.is_a?(Airbrake::Notice)
@@ -68,6 +68,7 @@ module Airbrake
 
     # @see Airbrake.close
     def close
+      @sync_sender.close
       @async_sender.close
     end
 
@@ -78,7 +79,13 @@ module Airbrake
 
     # @see Airbrake.merge_context
     def merge_context(context)
-      @context.merge!(context)
+      Airbrake::Context.current.merge!(context)
+    end
+
+    # @return [Boolean]
+    # @since v4.14.0
+    def has_filter?(filter_class) # rubocop:disable Naming/PredicateName
+      @filter_chain.includes?(filter_class)
     end
 
     private
@@ -116,7 +123,7 @@ module Airbrake
 
       logger.warn(
         "#{LOG_LABEL} falling back to sync delivery because there are no " \
-        "running async workers"
+        "running async workers",
       )
       @sync_sender
     end
@@ -128,6 +135,7 @@ module Airbrake
       # If true, then it's likely an internal library error. In this case return
       # at least some backtrace to simplify debugging.
       return caller_copy if clean_bt.empty?
+
       clean_bt
     end
   end

data/lib/airbrake-ruby/performance_breakdown.rb

@@ -5,23 +5,30 @@ 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
-  ) do
+  # rubocop:disable Metrics/ParameterLists
+  class PerformanceBreakdown
     include HashKeyable
     include Ignorable
     include Stashable
+    include Mergeable
+
+    attr_accessor :method, :route, :response_type, :groups, :timing, :time
 
     def initialize(
       method:,
       route:,
       response_type:,
       groups:,
-      start_time:,
-      end_time: Time.now
+      timing: nil,
+      time: Time.now
     )
-      super(method, route, response_type, groups, start_time, end_time)
+      @time_utc = TimeTruncate.utc_truncate_minutes(time)
+      @method = method
+      @route = route
+      @response_type = response_type
+      @groups = groups
+      @timing = timing
+      @time = time
     end
 
     def destination
@@ -37,9 +44,9 @@ module Airbrake
         'method' => method,
         'route' => route,
         'responseType' => response_type,
-        'time' => TimeTruncate.utc_truncate_minutes(start_time)
+        'time' => @time_utc,
       }.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

@@ -1,9 +1,10 @@
 module Airbrake
-  # QueryNotifier aggregates information about SQL queries and periodically sends
-  # collected data to Airbrake.
+  # PerformanceNotifier aggregates performance data and periodically sends it to
+  # Airbrake.
   #
   # @api public
   # @since v3.2.0
+  # rubocop:disable Metrics/ClassLength
   class PerformanceNotifier
     include Inspectable
     include Loggable
@@ -11,32 +12,29 @@ module Airbrake
     def initialize
       @config = Airbrake::Config.instance
       @flush_period = Airbrake::Config.instance.performance_stats_flush_period
-      @sender = SyncSender.new(:put)
-      @payload = {}
+      @async_sender = AsyncSender.new(:put, self.class.name)
+      @sync_sender = SyncSender.new(:put)
       @schedule_flush = nil
-      @mutex = Mutex.new
       @filter_chain = FilterChain.new
+
+      @payload = {}.extend(MonitorMixin)
+      @has_payload = @payload.new_cond
     end
 
-    # @param [Hash] resource
+    # @param [Hash] metric
     # @see Airbrake.notify_query
     # @see Airbrake.notify_request
-    def notify(resource)
-      promise = @config.check_configuration
-      return promise if promise.rejected?
-
-      promise = @config.check_performance_options(resource)
-      return promise if promise.rejected?
-
-      @filter_chain.refine(resource)
-      return if resource.ignored?
-
-      @mutex.synchronize do
-        update_payload(resource)
-        @flush_period > 0 ? schedule_flush(promise) : send(@payload, promise)
+    def notify(metric)
+      @payload.synchronize do
+        send_metric(metric, sync: false)
       end
+    end
 
-      promise
+    # @param [Hash] metric
+    # @since v4.10.0
+    # @see Airbrake.notify_queue_sync
+    def notify_sync(metric)
+      send_metric(metric, sync: true).value
     end
 
     # @see Airbrake.add_performance_filter
@@ -49,77 +47,131 @@ module Airbrake
       @filter_chain.delete_filter(filter_class)
     end
 
+    def close
+      @payload.synchronize do
+        @schedule_flush.kill if @schedule_flush
+        @sync_sender.close
+        @async_sender.close
+      end
+    end
+
     private
 
-    def update_payload(resource)
-      @payload[resource] ||= { total: Airbrake::Stat.new }
-      @payload[resource][:total].increment(resource.start_time, resource.end_time)
+    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
 
-      resource.groups.each do |name, ms|
-        @payload[resource][name] ||= Airbrake::Stat.new
-        @payload[resource][name].increment_ms(ms)
+            send(@async_sender, @payload, Airbrake::Promise.new)
+            @payload.clear
+          end
+        end
       end
     end
 
-    def schedule_flush(promise)
-      @schedule_flush ||= Thread.new do
-        sleep(@flush_period)
+    def send_metric(metric, sync:)
+      promise = check_configuration(metric)
+      return promise if promise.rejected?
 
-        payload = nil
-        @mutex.synchronize do
-          payload = @payload
-          @payload = {}
-          @schedule_flush = nil
-        end
+      @filter_chain.refine(metric)
+      if metric.ignored?
+        return Promise.new.reject("#{metric.class} was ignored by a filter")
+      end
 
-        send(payload, promise)
+      update_payload(metric)
+      if sync || @flush_period == 0
+        send(@sync_sender, @payload, promise)
+      else
+        @has_payload.signal
+        schedule_flush
       end
     end
 
-    def send(payload, promise)
-      signature = "#{self.class.name}##{__method__}"
-      raise "#{signature}: payload (#{payload}) cannot be empty. Race?" if payload.none?
+    def update_payload(metric)
+      if (total_stat = @payload[metric])
+        @payload.key(total_stat).merge(metric)
+      else
+        @payload[metric] = { total: Airbrake::Stat.new }
+      end
+
+      @payload[metric][:total].increment_ms(metric.timing)
+
+      metric.groups.each do |name, ms|
+        @payload[metric][name] ||= Airbrake::Stat.new
+        @payload[metric][name].increment_ms(ms)
+      end
+    end
+
+    def check_configuration(metric)
+      promise = @config.check_configuration
+      return promise if promise.rejected?
+
+      promise = @config.check_performance_options(metric)
+      return promise if promise.rejected?
 
-      logger.debug { "#{LOG_LABEL} #{signature}: #{payload}" }
+      if metric.timing && metric.timing == 0
+        return Promise.new.reject(':timing cannot be zero')
+      end
 
-      with_grouped_payload(payload) do |resource_hash, destination|
+      Promise.new
+    end
+
+    def send(sender, payload, promise)
+      raise "payload cannot be empty. Race?" if payload.none?
+
+      with_grouped_payload(payload) do |metric_hash, destination|
         url = URI.join(
-          @config.host,
-          "api/v5/projects/#{@config.project_id}/#{destination}"
+          @config.apm_host,
+          "api/v5/projects/#{@config.project_id}/#{destination}",
         )
-        @sender.send(resource_hash, promise, url)
+
+        logger.debug do
+          "#{LOG_LABEL} #{self.class.name}##{__method__}: #{metric_hash}"
+        end
+        sender.send(metric_hash, promise, url)
       end
 
       promise
     end
 
     def with_grouped_payload(raw_payload)
-      grouped_payload = raw_payload.group_by do |resource, _stats|
-        [resource.cargo, resource.destination]
+      grouped_payload = raw_payload.group_by do |metric, _stats|
+        [metric.cargo, metric.destination]
       end
 
-      grouped_payload.each do |(cargo, destination), resources|
+      grouped_payload.each do |(cargo, destination), metrics|
         payload = {}
-        payload[cargo] = serialize_resources(resources)
+        payload[cargo] = serialize_metrics(metrics)
         payload['environment'] = @config.environment if @config.environment
 
         yield(payload, destination)
       end
     end
 
-    def serialize_resources(resources)
-      resources.map do |resource, stats|
-        resource_hash = resource.to_h.merge!(stats[:total].to_h)
+    def serialize_metrics(metrics)
+      metrics.map do |metric, stats|
+        metric_hash = metric.to_h.merge!(stats[:total].to_h)
 
-        if resource.groups.any?
+        if metric.groups.any?
           group_stats = stats.reject { |name, _stat| name == :total }
-          resource_hash['groups'] = group_stats.merge(group_stats) do |_name, stat|
+          metric_hash['groups'] = group_stats.merge(group_stats) do |_name, stat|
             stat.to_h
           end
         end
 
-        resource_hash
+        metric_hash
       end
     end
   end
+  # rubocop:enable Metrics/ClassLength
 end

data/lib/airbrake-ruby/promise.rb

@@ -103,6 +103,7 @@ module Airbrake
     #   needed for compatibility but it shouldn't exist in the future
     def value
       return @value['ok'] if resolved?
+
       @value
     end
   end

data/lib/airbrake-ruby/query.rb

@@ -4,13 +4,15 @@ 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
-  ) 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, :timing, :time
 
     def initialize(
       method:,
@@ -19,10 +21,18 @@ module Airbrake
       func: nil,
       file: nil,
       line: nil,
-      start_time:,
-      end_time: Time.now
+      timing: nil,
+      time: Time.now
     )
-      super(method, route, query, func, file, line, start_time, end_time)
+      @time_utc = TimeTruncate.utc_truncate_minutes(time)
+      @method = method
+      @route = route
+      @query = query
+      @func = func
+      @file = file
+      @line = line
+      @timing = timing
+      @time = time
     end
 
     def destination
@@ -33,21 +43,17 @@ module Airbrake
       'queries'
     end
 
-    def groups
-      {}
-    end
-
     def to_h
       {
         'method' => method,
         'route' => route,
         'query' => query,
-        'time' => TimeTruncate.utc_truncate_minutes(start_time),
+        'time' => @time_utc,
         'function' => func,
         'file' => file,
-        'line' => line
+        '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

@@ -0,0 +1,65 @@
+module Airbrake
+  # Queue represents a queue (worker).
+  #
+  # @see Airbrake.notify_queue
+  # @api public
+  # @since v4.9.0
+  class Queue
+    include HashKeyable
+    include Ignorable
+    include Stashable
+
+    attr_accessor :queue, :error_count, :groups, :timing, :time
+
+    def initialize(
+      queue:,
+      error_count:,
+      groups: {},
+      timing: nil,
+      time: Time.now
+    )
+      @time_utc = TimeTruncate.utc_truncate_minutes(time)
+      @queue = queue
+      @error_count = error_count
+      @groups = groups
+      @timing = timing
+      @time = time
+    end
+
+    def destination
+      'queues-stats'
+    end
+
+    def cargo
+      'queues'
+    end
+
+    def to_h
+      {
+        'queue' => queue,
+        'errorCount' => error_count,
+        'time' => @time_utc,
+      }
+    end
+
+    def hash
+      {
+        'queue' => queue,
+        'time' => @time_utc,
+      }.hash
+    end
+
+    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
+end