celerbrake-ruby 0.1.0

data/lib/celerbrake-ruby/remote_settings.rb

@@ -0,0 +1,128 @@
+module Celerbrake
+  # 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. Supports proxies.
+  #
+  # @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 Celerbrake::Loggable
+
+    # @return [Hash{Symbol=>String}] metadata to be attached to every GET
+    #   request
+    QUERY_PARAMS = URI.encode_www_form(
+      notifier_name: Celerbrake::NOTIFIER_INFO[:name],
+      notifier_version: Celerbrake::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 [Celerbrake::RemoteSettings::SettingsData]
+    # @return [Celerbrake::RemoteSettings]
+    def self.poll(project_id, host, &block)
+      new(project_id, host, &block).poll
+    end
+
+    # @param [Integer] project_id
+    # @yield [data]
+    # @yieldparam data [Celerbrake::RemoteSettings::SettingsData]
+    def initialize(project_id, host, &block)
+      @data = SettingsData.new(project_id, {})
+      @host = host
+      @block = block
+      @config = Celerbrake::Config.instance
+      @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
+      uri = build_config_uri
+      https = build_https(uri)
+      req = Net::HTTP::Get.new(uri.request_uri)
+      response = nil
+
+      begin
+        response = https.request(req)
+      rescue StandardError => ex
+        reason = "#{LOG_LABEL} HTTP error: #{ex}"
+        logger.error(reason)
+        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
+
+    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 proxy_params
+      return unless @config.proxy.key?(:host)
+
+      [@config.proxy[:host], @config.proxy[:port], @config.proxy[:user],
+       @config.proxy[:password]]
+    end
+  end
+end

data/lib/celerbrake-ruby/request.rb

@@ -0,0 +1,48 @@
+module Celerbrake
+  # Request holds request data that powers route stats.
+  #
+  # @see Celerbrake.notify_request
+  # @api public
+  # @since v3.2.0
+  class Request
+    include HashKeyable
+    include Ignorable
+    include Stashable
+    include Mergeable
+    include Grouppable
+
+    attr_accessor :method, :route, :status_code, :timing, :time
+
+    def initialize(
+      method:,
+      route:,
+      status_code:,
+      timing: nil,
+      time: Time.now
+    )
+      @time_utc = TimeTruncate.utc_truncate_minutes(time)
+      @method = method
+      @route = route
+      @status_code = status_code
+      @timing = timing
+      @time = time
+    end
+
+    def destination
+      'routes-stats'
+    end
+
+    def cargo
+      'routes'
+    end
+
+    def to_h
+      {
+        'method' => method,
+        'route' => route,
+        'statusCode' => status_code,
+        'time' => @time_utc,
+      }.delete_if { |_key, val| val.nil? }
+    end
+  end
+end

data/lib/celerbrake-ruby/response.rb

@@ -0,0 +1,125 @@
+module Celerbrake
+  # Parses responses coming from the Celerbrake 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 the server cannot or will not
+    #   process the request due to something that is perceived to be a client
+    #   error
+    # @since v6.2.0
+    BAD_REQUEST = 400
+
+    # @return [Integer] HTTP code returned when client request has not been
+    #   completed because it lacks valid authentication credentials for the
+    #   requested resource
+    # @since v6.2.0
+    UNAUTHORIZED = 401
+
+    # @return [Integer] HTTP code returned when the server understands the
+    #   request but refuses to authorize it
+    # @since v6.2.0
+    FORBIDDEN = 403
+
+    # @return [Integer] HTTP code returned when the server would like to shut
+    #   down this unused connection
+    # @since v6.2.0
+    REQUEST_TIMEOUT = 408
+
+    # @return [Integer] HTTP code returned when there's a request conflict with
+    #   the current state of the target resource
+    # @since v6.2.0
+    CONFLICT = 409
+
+    # @return [Integer]
+    # @since v6.2.0
+    ENHANCE_YOUR_CALM = 420
+
+    # @return [Integer] HTTP code returned when an IP sends over 10k/min notices
+    TOO_MANY_REQUESTS = 429
+
+    # @return [Integer] HTTP code returned when the server encountered an
+    #   unexpected condition that prevented it from fulfilling the request
+    # @since v6.2.0
+    INTERNAL_SERVER_ERROR = 500
+
+    # @return [Integer] HTTP code returened when the server, while acting as a
+    #   gateway or proxy, received an invalid response from the upstream server
+    # @since v6.2.0
+    BAD_GATEWAY = 502
+
+    # @return [Integer] HTTP code returened when the server, while acting as a
+    #   gateway or proxy, did not get a response in time from the upstream
+    #   server that it needed in order to complete the request
+    # @since v6.2.0
+    GATEWAY_TIMEOUT = 504
+
+    class << self
+      include Loggable
+    end
+
+    # Parses HTTP responses from the Celerbrake API.
+    #
+    # @param [Net::HTTPResponse] response
+    # @return [Hash{String=>String}] parsed response
+    # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+    def self.parse(response)
+      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 BAD_REQUEST, UNAUTHORIZED, FORBIDDEN, ENHANCE_YOUR_CALM
+          parsed_body = JSON.parse(body)
+          logger.error("#{LOG_LABEL} #{parsed_body['message']}")
+          parsed_body.merge('code' => code, 'error' => parsed_body['message'])
+        when TOO_MANY_REQUESTS
+          parsed_body = JSON.parse(body)
+          msg = "#{LOG_LABEL} #{parsed_body['message']}"
+          logger.error(msg)
+          {
+            'code' => code,
+            '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}")
+          { 'code' => code, 'error' => body_msg }
+        end
+      rescue StandardError => ex
+        body_msg = truncated_body(body)
+        logger.error("#{LOG_LABEL} error while parsing body (#{ex}). Body: #{body_msg}")
+        { 'code' => code, '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/celerbrake-ruby/stashable.rb

@@ -0,0 +1,15 @@
+module Celerbrake
+  # Stashable should be included in any class that wants the ability to stash
+  # arbitrary objects. It is mainly used by data objects that users can access
+  # through filters.
+  #
+  # @since v4.4.0
+  # @api private
+  module Stashable
+    # @return [Hash{Symbol=>Object}] the hash with arbitrary objects to be used
+    #   in filters
+    def stash
+      @stash ||= {}
+    end
+  end
+end

data/lib/celerbrake-ruby/stat.rb

@@ -0,0 +1,66 @@
+require 'base64'
+
+module Celerbrake
+  # 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 metric (route or query,
+  # etc.). Incrementing a stat means pushing new performance statistics.
+  #
+  # @example
+  #   stat = Celerbrake::Stat.new
+  #   stat.increment_ms(2000)
+  #   stat.to_h # Pack and serialize data so it can be transmitted.
+  #
+  # @since v3.2.0
+  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(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
+      @mutex.synchronize do
+        tdigest.compress!
+        {
+          'count' => tdigest.size,
+          'sum' => sum,
+          'sumsq' => sumsq,
+          'tdigest' => Base64.strict_encode64(tdigest.as_small_bytes),
+        }
+      end
+    end
+
+    # Increments tdigest timings and updates tdigest with given +ms+ value.
+    #
+    # @param [Float] ms
+    # @return [void]
+    def increment_ms(ms)
+      @mutex.synchronize do
+        self.sum += ms
+        self.sumsq += ms * ms
+
+        tdigest.push(ms)
+      end
+    end
+
+    # We define custom inspect so that we weed out uninformative TDigest, which
+    # is also very slow to dump when we log Celerbrake::Stat.
+    #
+    # @return [String]
+    def inspect
+      "#<struct Celerbrake::Stat count=#{tdigest.size}, sum=#{sum}, sumsq=#{sumsq}>"
+    end
+    alias pretty_print inspect
+  end
+end

data/lib/celerbrake-ruby/sync_sender.rb

@@ -0,0 +1,145 @@
+module Celerbrake
+  # Responsible for sending data to Celerbrake 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
+
+    # @return [Array<Integer>] response codes that are good to be backlogged
+    # @since v6.2.0
+    BACKLOGGABLE_STATUS_CODES = [
+      Response::BAD_REQUEST,
+      Response::FORBIDDEN,
+      Response::ENHANCE_YOUR_CALM,
+      Response::REQUEST_TIMEOUT,
+      Response::CONFLICT,
+      Response::TOO_MANY_REQUESTS,
+      Response::INTERNAL_SERVER_ERROR,
+      Response::BAD_GATEWAY,
+      Response::GATEWAY_TIMEOUT,
+    ].freeze
+
+    include Loggable
+
+    # @param [Symbol] method HTTP method to use to send payload
+    def initialize(method = :post)
+      @config = Celerbrake::Config.instance
+      @method = method
+      @rate_limit_reset = Time.now
+      @backlog = Backlog.new(self) if @config.backlog
+    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.error_endpoint)
+      return promise if rate_limited_ip?(promise)
+
+      req = build_request(endpoint, data)
+      return promise if missing_body?(req, promise)
+
+      begin
+        response = build_https(endpoint).request(req)
+      rescue StandardError => ex
+        reason = "#{LOG_LABEL} HTTP error: #{ex}"
+        logger.error(reason)
+        return promise.reject(reason)
+      end
+
+      parsed_resp = Response.parse(response)
+      handle_rate_limit(parsed_resp)
+      @backlog << [data, endpoint] if add_to_backlog?(parsed_resp)
+
+      return promise.reject(parsed_resp['error']) if parsed_resp.key?('error')
+
+      promise.resolve(parsed_resp)
+    end
+
+    # Closes all the resources that this sender has allocated.
+    #
+    # @return [void]
+    # @since v6.2.0
+    def close
+      @backlog.close
+    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'] =
+        "#{Celerbrake::NOTIFIER_INFO[:name]}/#{Celerbrake::CELERBRAKE_RUBY_VERSION} " \
+        "Ruby/#{RUBY_VERSION}"
+
+      req
+    end
+
+    def handle_rate_limit(parsed_resp)
+      return unless parsed_resp.key?('rate_limit_reset')
+
+      @rate_limit_reset = parsed_resp['rate_limit_reset']
+    end
+
+    def add_to_backlog?(parsed_resp)
+      return unless @backlog
+      return unless parsed_resp.key?('code')
+
+      BACKLOGGABLE_STATUS_CODES.include?(parsed_resp['code'])
+    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"
+        logger.error(reason)
+        promise.reject(reason)
+      end
+
+      missing
+    end
+  end
+end