airbrake-ruby 3.2.2-java

data/lib/airbrake-ruby/performance_notifier.rb

@@ -0,0 +1,161 @@
+module Airbrake
+  # QueryNotifier aggregates information about SQL queries and periodically sends
+  # collected data to Airbrake.
+  #
+  # @api public
+  # @since v3.2.0
+  class PerformanceNotifier
+    # @param [Airbrake::Config] config
+    def initialize(config)
+      @config =
+        if config.is_a?(Config)
+          config
+        else
+          loc = caller_locations(1..1).first
+          signature = "#{self.class.name}##{__method__}"
+          warn(
+            "#{loc.path}:#{loc.lineno}: warning: passing a Hash to #{signature} " \
+            'is deprecated. Pass `Airbrake::Config` instead'
+          )
+          Config.new(config)
+        end
+
+      @flush_period = @config.performance_stats_flush_period
+      @sender = SyncSender.new(@config, :put)
+      @payload = {}
+      @schedule_flush = nil
+      @mutex = Mutex.new
+      @filter_chain = FilterChain.new
+    end
+
+    # @param [Hash] resource
+    # @param [Airbrake::Promise] promise
+    # @see Airbrake.notify_query
+    # @see Airbrake.notify_request
+    def notify(resource, promise = Airbrake::Promise.new)
+      if @config.ignored_environment?
+        return promise.reject("The '#{@config.environment}' environment is ignored")
+      end
+
+      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
+      end
+
+      promise
+    end
+
+    # @see Airbrake.add_performance_filter
+    def add_filter(filter = nil, &block)
+      @filter_chain.add_filter(block_given? ? block : filter)
+    end
+
+    # @see Airbrake.delete_performance_filter
+    def delete_filter(filter_class)
+      @filter_chain.delete_filter(filter_class)
+    end
+
+    private
+
+    def schedule_flush(promise)
+      @schedule_flush ||= Thread.new do
+        sleep(@flush_period)
+
+        payload = nil
+        @mutex.synchronize do
+          payload = @payload
+          @payload = {}
+          @schedule_flush = nil
+        end
+
+        send(payload, promise)
+      end
+    end
+
+    def send(payload, promise)
+      signature = "#{self.class.name}##{__method__}"
+      raise "#{signature}: payload (#{payload}) cannot be empty. Race?" if payload.none?
+
+      @config.logger.debug("#{LOG_LABEL} #{signature}: #{payload}")
+
+      payload.group_by { |k, _v| k.name }.each do |resource_name, data|
+        @sender.send(
+          { resource_name => data.map { |k, v| k.to_h.merge!(v.to_h) } },
+          promise,
+          URI.join(
+            @config.host,
+            "api/v5/projects/#{@config.project_id}/#{resource_name}-stats"
+          )
+        )
+      end
+    end
+  end
+
+  # Request holds request data that powers route stats.
+  #
+  # @see Airbrake.notify_request
+  # @api public
+  # @since v3.2.0
+  Request = Struct.new(:method, :route, :status_code, :start_time, :end_time) do
+    include HashKeyable
+    include Ignorable
+
+    def initialize(method:, route:, status_code:, start_time:, end_time: Time.now)
+      @ignored = false
+      super(method, route, status_code, start_time, end_time)
+    end
+
+    def name
+      'routes'
+    end
+
+    def to_h
+      {
+        'method' => method,
+        'route' => route,
+        'statusCode' => status_code,
+        'time' => TimeTruncate.utc_truncate_minutes(start_time)
+      }
+    end
+  end
+
+  # Query holds SQL query data that powers SQL query collection.
+  #
+  # @see Airbrake.notify_query
+  # @api public
+  # @since v3.2.0
+  Query = Struct.new(:method, :route, :query, :start_time, :end_time) do
+    include HashKeyable
+    include Ignorable
+
+    def initialize(method:, route:, query:, start_time:, end_time: Time.now)
+      super(method, route, query, start_time, end_time)
+    end
+
+    def name
+      'queries'
+    end
+
+    def to_h
+      {
+        'method' => method,
+        'route' => route,
+        'query' => query,
+        'time' => TimeTruncate.utc_truncate_minutes(start_time)
+      }
+    end
+  end
+end

data/lib/airbrake-ruby/promise.rb

@@ -0,0 +1,99 @@
+module Airbrake
+  # Represents a simplified promise object (similar to promises found in
+  # JavaScript), which allows chaining callbacks that are executed when the
+  # promise is either resolved or rejected.
+  #
+  # @see https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_Objects/Promise
+  # @see https://github.com/ruby-concurrency/concurrent-ruby/blob/master/lib/concurrent/promise.rb
+  # @since v1.7.0
+  class Promise
+    # @api private
+    # @return [Hash<String,String>] either successful response containing the
+    #   +id+ key or unsuccessful response containing the +error+ key
+    # @note This is a non-blocking call!
+    attr_reader :value
+
+    def initialize
+      @on_resolved = []
+      @on_rejected = []
+      @value = {}
+      @mutex = Mutex.new
+    end
+
+    # Attaches a callback to be executed when the promise is resolved.
+    #
+    # @example
+    #   Airbrake::Promise.new.then { |response| puts response }
+    #   #=> {"id"=>"00054415-8201-e9c6-65d6-fc4d231d2871",
+    #   #    "url"=>"http://localhost/locate/00054415-8201-e9c6-65d6-fc4d231d2871"}
+    #
+    # @yield [response]
+    # @yieldparam response [Hash<String,String>] Contains the `id` & `url` keys
+    # @return [self]
+    def then(&block)
+      @mutex.synchronize do
+        if @value.key?('id')
+          yield(@value)
+          return self
+        end
+
+        @on_resolved << block
+      end
+
+      self
+    end
+
+    # Attaches a callback to be executed when the promise is rejected.
+    #
+    # @example
+    #   Airbrake::Promise.new.rescue { |error| raise error }
+    #
+    # @yield [error] The error message from the API
+    # @yieldparam error [String]
+    # @return [self]
+    def rescue(&block)
+      @mutex.synchronize do
+        if @value.key?('error')
+          yield(@value['error'])
+          return self
+        end
+
+        @on_rejected << block
+      end
+
+      self
+    end
+
+    # Resolves the promise.
+    #
+    # @example
+    #   Airbrake::Promise.new.resolve('id' => '123')
+    #
+    # @param response [Hash<String,String>]
+    # @return [self]
+    def resolve(response)
+      @mutex.synchronize do
+        @value = response
+        @on_resolved.each { |callback| callback.call(response) }
+      end
+
+      self
+    end
+
+    # Rejects the promise.
+    #
+    # @example
+    #   Airbrake::Promise.new.reject('Something went wrong')
+    #
+    # @param error [String]
+    # @return [self]
+    def reject(error)
+      @mutex.synchronize do
+        @value['error'] = error
+        @on_rejected.each { |callback| callback.call(error) }
+      end
+
+      self
+    end
+  end
+end

data/lib/airbrake-ruby/response.rb

@@ -0,0 +1,71 @@
+module Airbrake
+  # Parses responses coming from the Airbrake API. Handles HTTP errors by
+  # logging them.
+  #
+  # @api private
+  # @since v1.0.0
+  module Response
+    # @return [Integer] the limit of the response body
+    TRUNCATE_LIMIT = 100
+
+    # @return [Integer] HTTP code returned when an IP sends over 10k/min notices
+    TOO_MANY_REQUESTS = 429
+
+    # Parses HTTP responses from the Airbrake API.
+    #
+    # @param [Net::HTTPResponse] response
+    # @param [Logger] logger
+    # @return [Hash{String=>String}] parsed response
+    # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+    def self.parse(response, logger)
+      code = response.code.to_i
+      body = response.body
+
+      begin
+        case code
+        when 200, 204
+          logger.debug("#{LOG_LABEL} #{name} (#{code}): #{body}")
+          { response.msg => response.body }
+        when 201
+          parsed_body = JSON.parse(body)
+          logger.debug("#{LOG_LABEL} #{name} (#{code}): #{parsed_body}")
+          parsed_body
+        when 400, 401, 403, 420
+          parsed_body = JSON.parse(body)
+          logger.error("#{LOG_LABEL} #{parsed_body['message']}")
+          parsed_body
+        when TOO_MANY_REQUESTS
+          parsed_body = JSON.parse(body)
+          msg = "#{LOG_LABEL} #{parsed_body['message']}"
+          logger.error(msg)
+          { 'error' => msg, 'rate_limit_reset' => rate_limit_reset(response) }
+        else
+          body_msg = truncated_body(body)
+          logger.error("#{LOG_LABEL} unexpected code (#{code}). Body: #{body_msg}")
+          { 'error' => body_msg }
+        end
+      rescue StandardError => ex
+        body_msg = truncated_body(body)
+        logger.error("#{LOG_LABEL} error while parsing body (#{ex}). Body: #{body_msg}")
+        { 'error' => ex.inspect }
+      end
+    end
+    # rubocop:enable Metrics/MethodLength, Metrics/AbcSize
+
+    def self.truncated_body(body)
+      if body.nil?
+        '[EMPTY_BODY]'.freeze
+      elsif body.length > TRUNCATE_LIMIT
+        body[0..TRUNCATE_LIMIT] << '...'
+      else
+        body
+      end
+    end
+    private_class_method :truncated_body
+
+    def self.rate_limit_reset(response)
+      Time.now + response['X-RateLimit-Delay'].to_i
+    end
+    private_class_method :rate_limit_reset
+  end
+end

data/lib/airbrake-ruby/stat.rb

@@ -0,0 +1,56 @@
+require 'base64'
+
+module Airbrake
+  # Stat is a data structure that allows accumulating performance data (route
+  # performance, SQL query performance and such). It's powered by TDigests.
+  #
+  # Usually, one Stat corresponds to one resource (route or query,
+  # etc.). Incrementing a stat means pushing new performance statistics.
+  #
+  # @example
+  #   stat = Airbrake::Stat.new
+  #   stat.increment(Time.now - 200)
+  #   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
+    # @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)
+    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)
+      }
+    end
+
+    # Increments count and updates performance with the difference of +end_time+
+    # and +start_time+.
+    #
+    # @param [Date] start_time
+    # @param [Date] end_time
+    # @return [void]
+    def increment(start_time, end_time = nil)
+      end_time ||= Time.new
+
+      self.count += 1
+
+      ms = (end_time - start_time) * 1000
+      self.sum += ms
+      self.sumsq += ms * ms
+
+      tdigest.push(ms)
+    end
+  end
+end

data/lib/airbrake-ruby/sync_sender.rb

@@ -0,0 +1,111 @@
+module Airbrake
+  # Responsible for sending data to Airbrake synchronously via PUT or POST
+  # methods. Supports proxies.
+  #
+  # @see AsyncSender
+  # @api private
+  # @since v1.0.0
+  class SyncSender
+    # @return [String] body for HTTP requests
+    CONTENT_TYPE = 'application/json'.freeze
+
+    # @param [Airbrake::Config] config
+    def initialize(config, method = :post)
+      @config = config
+      @method = method
+      @rate_limit_reset = Time.now
+    end
+
+    # Sends a POST or PUT request to the given +endpoint+ with the +data+ payload.
+    #
+    # @param [#to_json] data
+    # @param [URI::HTTPS] endpoint
+    # @return [Hash{String=>String}] the parsed HTTP response
+    def send(data, promise, endpoint = @config.endpoint)
+      return promise if rate_limited_ip?(promise)
+
+      response = nil
+      req = build_request(endpoint, data)
+
+      return promise if missing_body?(req, promise)
+
+      https = build_https(endpoint)
+
+      begin
+        response = https.request(req)
+      rescue StandardError => ex
+        reason = "#{LOG_LABEL} HTTP error: #{ex}"
+        @config.logger.error(reason)
+        return promise.reject(reason)
+      end
+
+      parsed_resp = Response.parse(response, @config.logger)
+      if parsed_resp.key?('rate_limit_reset')
+        @rate_limit_reset = parsed_resp['rate_limit_reset']
+      end
+
+      return promise.reject(parsed_resp['error']) if parsed_resp.key?('error')
+      promise.resolve(parsed_resp)
+    end
+
+    private
+
+    def build_https(uri)
+      Net::HTTP.new(uri.host, uri.port, *proxy_params).tap do |https|
+        https.use_ssl = uri.is_a?(URI::HTTPS)
+        if @config.timeout
+          https.open_timeout = @config.timeout
+          https.read_timeout = @config.timeout
+        end
+      end
+    end
+
+    def build_request(uri, data)
+      req =
+        if @method == :put
+          Net::HTTP::Put.new(uri.request_uri)
+        else
+          Net::HTTP::Post.new(uri.request_uri)
+        end
+
+      build_request_body(req, data)
+    end
+
+    def build_request_body(req, data)
+      req.body = data.to_json
+
+      req['Authorization'] = "Bearer #{@config.project_key}"
+      req['Content-Type'] = CONTENT_TYPE
+      req['User-Agent'] =
+        "#{Airbrake::Notice::NOTIFIER[:name]}/#{Airbrake::AIRBRAKE_RUBY_VERSION}" \
+        " Ruby/#{RUBY_VERSION}"
+
+      req
+    end
+
+    def proxy_params
+      return unless @config.proxy.key?(:host)
+
+      [@config.proxy[:host], @config.proxy[:port], @config.proxy[:user],
+       @config.proxy[:password]]
+    end
+
+    def rate_limited_ip?(promise)
+      rate_limited = Time.now < @rate_limit_reset
+      promise.reject("#{LOG_LABEL} IP is rate limited") if rate_limited
+      rate_limited
+    end
+
+    def missing_body?(req, promise)
+      missing = req.body.nil?
+
+      if missing
+        reason = "#{LOG_LABEL} data was not sent because of missing body"
+        @config.logger.error(reason)
+        promise.reject(reason)
+      end
+
+      missing
+    end
+  end
+end