airbrake-ruby 4.1.0 → 5.0.0

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
@@ -25,34 +25,38 @@ module Airbrake
       @async_sender = AsyncSender.new
       @sync_sender = SyncSender.new
 
-      add_default_filters
+      DEFAULT_FILTERS.each { |filter| add_filter(filter.new) }
+
+      add_filter(Airbrake::Filters::ContextFilter.new(@context))
+      add_filter(Airbrake::Filters::ExceptionAttributesFilter.new)
     end
 
-    # @macro see_public_api_method
+    # @see Airbrake.notify
     def notify(exception, params = {}, &block)
       send_notice(exception, params, default_sender, &block)
     end
 
-    # @macro see_public_api_method
+    # @see Airbrake.notify_sync
     def notify_sync(exception, params = {}, &block)
       send_notice(exception, params, @sync_sender, &block).value
     end
 
-    # @macro see_public_api_method
+    # @see Airbrake.add_filte
     def add_filter(filter = nil, &block)
       @filter_chain.add_filter(block_given? ? block : filter)
     end
 
-    # @macro see_public_api_method
+    # @see Airbrake.delete_filter
     def delete_filter(filter_class)
       @filter_chain.delete_filter(filter_class)
     end
 
-    # @macro see_public_api_method
+    # @see Airbrake.build_notice
     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)
@@ -63,21 +67,27 @@ module Airbrake
       end
     end
 
-    # @macro see_public_api_method
+    # @see Airbrake.close
     def close
       @async_sender.close
     end
 
-    # @macro see_public_api_method
+    # @see Airbrake.configured?
     def configured?
       @config.valid?
     end
 
-    # @macro see_public_api_method
+    # @see Airbrake.merge_context
     def merge_context(context)
       @context.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
 
     def convert_to_exception(ex)
@@ -113,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
@@ -125,37 +135,8 @@ 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
-
-    # rubocop:disable Metrics/AbcSize
-    def add_default_filters
-      DEFAULT_FILTERS.each { |f| add_filter(f.new) }
-
-      if (whitelist_keys = @config.whitelist_keys).any?
-        add_filter(Airbrake::Filters::KeysWhitelist.new(whitelist_keys))
-      end
 
-      if (blacklist_keys = @config.blacklist_keys).any?
-        add_filter(Airbrake::Filters::KeysBlacklist.new(blacklist_keys))
-      end
-
-      add_filter(Airbrake::Filters::ContextFilter.new(@context))
-      add_filter(Airbrake::Filters::ExceptionAttributesFilter.new)
-
-      return unless (root_directory = @config.root_directory)
-      [
-        Airbrake::Filters::RootDirectoryFilter,
-        Airbrake::Filters::GitRevisionFilter,
-        Airbrake::Filters::GitRepositoryFilter
-      ].each do |filter|
-        add_filter(filter.new(root_directory))
-      end
-
-      add_filter(
-        Airbrake::Filters::GitLastCheckoutFilter.new(root_directory)
-      )
+      clean_bt
     end
-    # rubocop:enable Metrics/AbcSize
   end
 end

data/lib/airbrake-ruby/performance_breakdown.rb

@@ -0,0 +1,52 @@
+module Airbrake
+  # PerformanceBreakdown holds data that shows how much time a request spent
+  # doing certaing subtasks such as (DB querying, view rendering, etc).
+  #
+  # @see Airbrake.notify_breakdown
+  # @api public
+  # @since v4.2.0
+  # 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:,
+      timing: nil,
+      time: Time.now
+    )
+      @time_utc = TimeTruncate.utc_truncate_minutes(time)
+      @method = method
+      @route = route
+      @response_type = response_type
+      @groups = groups
+      @timing = timing
+      @time = time
+    end
+
+    def destination
+      'routes-breakdowns'
+    end
+
+    def cargo
+      'routes'
+    end
+
+    def to_h
+      {
+        'method' => method,
+        'route' => route,
+        'responseType' => response_type,
+        'time' => @time_utc,
+      }.delete_if { |_key, val| val.nil? }
+    end
+  end
+  # rubocop:enable Metrics/ParameterLists
+end

data/lib/airbrake-ruby/performance_notifier.rb

@@ -4,6 +4,7 @@ module Airbrake
   #
   # @api public
   # @since v3.2.0
+  # rubocop:disable Metrics/ClassLength
   class PerformanceNotifier
     include Inspectable
     include Loggable
@@ -11,40 +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)
+      @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
     # @see Airbrake.notify_query
     # @see Airbrake.notify_request
     def notify(resource)
-      promise = @config.check_configuration
-      return promise if promise.rejected?
-
-      promise = Airbrake::Promise.new
-      unless @config.performance_stats
-        return promise.reject("The Performance Stats feature is disabled")
-      end
-
-      @filter_chain.refine(resource)
-      return if resource.ignored?
-
-      @mutex.synchronize do
-        @payload[resource] ||= Airbrake::Stat.new
-        @payload[resource].increment(resource.start_time, resource.end_time)
-
-        if @flush_period > 0
-          schedule_flush(promise)
-        else
-          send(@payload, promise)
-        end
+      @payload.synchronize do
+        send_resource(resource, sync: false)
       end
+    end
 
-      promise
+    # @param [Hash] resource
+    # @since v4.10.0
+    # @see Airbrake.notify_queue_sync
+    def notify_sync(resource)
+      send_resource(resource, sync: true).value
     end
 
     # @see Airbrake.add_performance_filter
@@ -57,44 +47,131 @@ module Airbrake
       @filter_chain.delete_filter(filter_class)
     end
 
+    def close
+      @payload.synchronize do
+        @schedule_flush.kill if @schedule_flush
+        @async_sender.close
+        logger.debug("#{LOG_LABEL} performance notifier closed")
+      end
+    end
+
     private
 
-    def schedule_flush(promise)
+    def schedule_flush
       @schedule_flush ||= Thread.new do
-        sleep(@flush_period)
-
-        payload = nil
-        @mutex.synchronize do
-          payload = @payload
-          @payload = {}
-          @schedule_flush = nil
+        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?
 
-        send(payload, promise)
+      @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
 
-    # rubocop:disable Metrics/AbcSize
-    def send(payload, promise)
-      signature = "#{self.class.name}##{__method__}"
-      raise "#{signature}: payload (#{payload}) cannot be empty. Race?" if payload.none?
+    def update_payload(resource)
+      if (total_stat = @payload[resource])
+        @payload.key(total_stat).merge(resource)
+      else
+        @payload[resource] = { total: Airbrake::Stat.new }
+      end
 
-      logger.debug("#{LOG_LABEL} #{signature}: #{payload}")
+      @payload[resource][:total].increment_ms(resource.timing)
 
-      payload.group_by { |k, _v| k.name }.each do |resource_name, data|
-        data = { resource_name => data.map { |k, v| k.to_h.merge!(v.to_h) } }
-        data['environment'] = @config.environment if @config.environment
+      resource.groups.each do |name, ms|
+        @payload[resource][name] ||= Airbrake::Stat.new
+        @payload[resource][name].increment_ms(ms)
+      end
+    end
 
-        @sender.send(
-          data,
-          promise,
-          URI.join(
-            @config.host,
-            "api/v5/projects/#{@config.project_id}/#{resource_name}-stats"
-          )
+    def check_configuration(resource)
+      promise = @config.check_configuration
+      return promise if promise.rejected?
+
+      promise = @config.check_performance_options(resource)
+      return promise if promise.rejected?
+
+      if resource.timing && resource.timing == 0
+        return Promise.new.reject(':timing cannot be zero')
+      end
+
+      Promise.new
+    end
+
+    def send(sender, payload, promise)
+      raise "payload cannot be empty. Race?" if payload.none?
+
+      with_grouped_payload(payload) do |resource_hash, destination|
+        url = URI.join(
+          @config.apm_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
+
+      promise
+    end
+
+    def with_grouped_payload(raw_payload)
+      grouped_payload = raw_payload.group_by do |resource, _stats|
+        [resource.cargo, resource.destination]
+      end
+
+      grouped_payload.each do |(cargo, destination), resources|
+        payload = {}
+        payload[cargo] = serialize_resources(resources)
+        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)
+
+        if resource.groups.any?
+          group_stats = stats.reject { |name, _stat| name == :total }
+          resource_hash['groups'] = group_stats.merge(group_stats) do |_name, stat|
+            stat.to_h
+          end
+        end
+
+        resource_hash
       end
     end
-    # rubocop:enable Metrics/AbcSize
   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,12 +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:,
@@ -18,13 +21,25 @@ 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
+      'queries-stats'
     end
 
-    def name
+    def cargo
       'queries'
     end
 
@@ -33,12 +48,12 @@ module Airbrake
         '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

data/lib/airbrake-ruby/remote_settings/settings_data.rb

@@ -0,0 +1,120 @@
+module Airbrake
+  class RemoteSettings
+    # SettingsData is a container, which wraps JSON payload returned by the
+    # remote settings API. It exposes the payload via convenient methods and
+    # also ensures that in case some data from the payload is missing, a default
+    # value would be returned instead.
+    #
+    # @example
+    #   # Create the object and pass initial data (empty hash).
+    #   settings_data = SettingsData.new({})
+    #
+    #   settings_data.interval #=> 600
+    #
+    # @since 5.0.0
+    # @api private
+    class SettingsData
+      # @return [Integer] how frequently we should poll the config API
+      DEFAULT_INTERVAL = 600
+
+      # @return [String] API version of the S3 API to poll
+      API_VER = '2020-06-18'.freeze
+
+      # @return [String] what path to poll
+      CONFIG_ROUTE_PATTERN =
+        "%<host>s/#{API_VER}/config/%<project_id>s/config.json".freeze
+
+      # @return [Hash{Symbol=>String}] the hash of all supported settings where
+      #   the value is the name of the setting returned by the API
+      SETTINGS = {
+        errors: 'errors'.freeze,
+        apm: 'apm'.freeze,
+      }.freeze
+
+      # @param [Integer] project_id
+      # @param [Hash{String=>Object}] data
+      def initialize(project_id, data)
+        @project_id = project_id
+        @data = data
+      end
+
+      # Merges the given +hash+ with internal data.
+      #
+      # @param [Hash{String=>Object}] hash
+      # @return [self]
+      def merge!(hash)
+        @data.merge!(hash)
+
+        self
+      end
+
+      # @return [Integer] how frequently we should poll for the config
+      def interval
+        return DEFAULT_INTERVAL if !@data.key?('poll_sec') || !@data['poll_sec']
+
+        @data['poll_sec'] > 0 ? @data['poll_sec'] : DEFAULT_INTERVAL
+      end
+
+      # @param [String] remote_config_host
+      # @return [String] where the config is stored on S3.
+      def config_route(remote_config_host)
+        if !@data.key?('config_route') || !@data['config_route']
+          return format(
+            CONFIG_ROUTE_PATTERN,
+            host: remote_config_host.chomp('/'),
+            project_id: @project_id,
+          )
+        end
+
+        format(
+          CONFIG_ROUTE_PATTERN,
+          host: @data['config_route'].chomp('/'),
+          project_id: @project_id,
+        )
+      end
+
+      # @return [Boolean] whether error notifications are enabled
+      def error_notifications?
+        return true unless (s = find_setting(SETTINGS[:errors]))
+
+        s['enabled']
+      end
+
+      # @return [Boolean] whether APM is enabled
+      def performance_stats?
+        return true unless (s = find_setting(SETTINGS[:apm]))
+
+        s['enabled']
+      end
+
+      # @return [String, nil] the host, which provides the API endpoint to which
+      #   exceptions should be sent
+      def error_host
+        return unless (s = find_setting(SETTINGS[:errors]))
+
+        s['endpoint']
+      end
+
+      # @return [String, nil] the host, which provides the API endpoint to which
+      #   APM data should be sent
+      def apm_host
+        return unless (s = find_setting(SETTINGS[:apm]))
+
+        s['endpoint']
+      end
+
+      # @return [Hash{String=>Object}] raw representation of JSON payload
+      def to_h
+        @data.dup
+      end
+
+      private
+
+      def find_setting(name)
+        return unless @data.key?('settings')
+
+        @data['settings'].find { |s| s['name'] == name }
+      end
+    end
+  end
+end