airbrake-ruby 4.8.0 → 5.2.0

data/lib/airbrake-ruby/performance_breakdown.rb

@@ -5,24 +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
     )
-      @start_time_utc = TimeTruncate.utc_truncate_minutes(start_time)
-      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
@@ -38,9 +44,9 @@ module Airbrake
         'method' => method,
         'route' => route,
         'responseType' => response_type,
-        'time' => @start_time_utc
+        '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

@@ -4,6 +4,7 @@ module Airbrake
   #
   # @api public
   # @since v3.2.0
+  # rubocop:disable Metrics/ClassLength
   class PerformanceNotifier
     include Inspectable
     include Loggable
@@ -11,33 +12,29 @@ module Airbrake
     def initialize
       @config = Airbrake::Config.instance
       @flush_period = Airbrake::Config.instance.performance_stats_flush_period
-      @sender = AsyncSender.new(:put)
-      @payload = {}
+      @async_sender = AsyncSender.new(:put)
+      @sync_sender = SyncSender.new(:put)
       @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)
-      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 : send(@payload, promise)
+      @payload.synchronize do
+        send_resource(resource, sync: false)
       end
+    end
 
-      promise.resolve(:success)
+    # @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
@@ -51,73 +48,97 @@ module Airbrake
     end
 
     def close
-      @mutex.synchronize do
+      @payload.synchronize do
         @schedule_flush.kill if @schedule_flush
-        @sender.close
+        @async_sender.close
         logger.debug("#{LOG_LABEL} performance notifier closed")
       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
 
-      resource.groups.each do |name, ms|
-        @payload[resource][name] ||= Airbrake::Stat.new
-        @payload[resource][name].increment_ms(ms)
+            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 schedule_flush
-      return if @payload.empty?
+    def send_resource(resource, sync:)
+      promise = check_configuration(resource)
+      return promise if promise.rejected?
 
-      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
+      @filter_chain.refine(resource)
+      if resource.ignored?
+        return Promise.new.reject("#{resource.class} was ignored by a filter")
       end
 
-      @schedule_flush ||= spawn_timer
+      update_payload(resource)
+      if sync || @flush_period == 0
+        send(@sync_sender, @payload, promise)
+      else
+        @has_payload.signal
+        schedule_flush
+      end
     end
 
-    def spawn_timer
-      Thread.new do
-        loop do
-          if @payload.none?
-            @waiting = true
-            Thread.stop
-            @waiting = false
-          end
-
-          sleep(@flush_period)
+    def update_payload(resource)
+      if (total_stat = @payload[resource])
+        @payload.key(total_stat).merge(resource)
+      else
+        @payload[resource] = { total: Airbrake::Stat.new }
+      end
 
-          payload = nil
-          @mutex.synchronize do
-            payload = @payload
-            @payload = {}
-          end
+      @payload[resource][:total].increment_ms(resource.timing)
 
-          send(payload, Airbrake::Promise.new)
-        end
+      resource.groups.each do |name, ms|
+        @payload[resource][name] ||= Airbrake::Stat.new
+        @payload[resource][name].increment_ms(ms)
       end
     end
 
-    def send(payload, promise)
-      signature = "#{self.class.name}##{__method__}"
-      raise "#{signature}: payload (#{payload}) cannot be empty. Race?" if payload.none?
+    def check_configuration(resource)
+      promise = @config.check_configuration
+      return promise if promise.rejected?
+
+      promise = @config.check_performance_options(resource)
+      return promise if promise.rejected?
 
-      logger.debug { "#{LOG_LABEL} #{signature}: #{payload}" }
+      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.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__}: #{resource_hash}"
+        end
+        sender.send(resource_hash, promise, url)
       end
 
       promise
@@ -152,4 +173,5 @@ module Airbrake
       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,11 +21,18 @@ module Airbrake
       func: nil,
       file: nil,
       line: nil,
-      start_time:,
-      end_time: Time.now
+      timing: nil,
+      time: Time.now
     )
-      @start_time_utc = TimeTruncate.utc_truncate_minutes(start_time)
-      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
@@ -34,21 +43,17 @@ module Airbrake
       'queries'
     end
 
-    def groups
-      {}
-    end
-
     def to_h
       {
         'method' => method,
         'route' => route,
         'query' => query,
-        'time' => @start_time_utc,
+        '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.rb

@@ -0,0 +1,105 @@
+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
+  #
+  # @since v5.0.0
+  # @api private
+  class RemoteSettings
+    include Airbrake::Loggable
+
+    # @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
+
+    # @return [String]
+    HTTP_OK = '200'.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.
+    #
+    # @return [self]
+    def poll
+      @poll ||= Thread.new do
+        @block.call(@data)
+
+        loop do
+          @block.call(@data.merge!(fetch_config))
+          sleep(@data.interval)
+        end
+      end
+
+      self
+    end
+
+    # Stops the background poller thread.
+    #
+    # @return [void]
+    def stop_polling
+      @poll.kill if @poll
+    end
+
+    private
+
+    def fetch_config
+      response = nil
+      begin
+        response = Net::HTTP.get_response(build_config_uri)
+      rescue StandardError => ex
+        logger.error(ex)
+        return {}
+      end
+
+      unless response.code == HTTP_OK
+        logger.error(response.body)
+        return {}
+      end
+
+      json = nil
+      begin
+        json = JSON.parse(response.body)
+      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
+  end
+end