flare 0.4.2 → 0.5.0

data/lib/flare/cli/requests_command.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require "json"
+require_relative "local_spans"
+require_relative "output"
+
+module Flare
+  # Lists the most recent requests from the local development spans database,
+  # so you (or a coding agent) can check a change without opening /flare.
+  class RequestsCommand
+    include CLI::LocalSpans
+    include CLI::Output
+
+    def initialize(argv)
+      parse_options(argv, banner: "Usage: flare requests [options]", last_help: "Number of requests to show")
+    end
+
+    def run
+      requests = read_local_spans(@database_path) { |storage| recent_requests(storage, @limit) }
+
+      if @json
+        puts JSON.pretty_generate(requests)
+      elsif requests.empty?
+        puts "No requests recorded yet."
+      else
+        requests.each { |request| puts format_row(request) }
+      end
+    end
+
+    private
+
+    def format_row(request)
+      [
+        dim(request[:started_at]),
+        request[:method].to_s.ljust(6),
+        request[:status].to_s.ljust(3),
+        format("%8.1fms", request[:duration_ms]),
+        format("%4d queries", request[:queries]),
+        request[:path],
+        endpoint(request)&.then { |name| dim(name) },
+        dim(request[:trace_id]),
+      ].compact.join("  ")
+    end
+  end
+end

data/lib/flare/cli/setup_command.rb

@@ -8,14 +8,20 @@ require "net/http"
 require "uri"
 require "json"
 require "fileutils"
+require "timeout"
 require_relative "output"
+require_relative "project"
 
 module Flare
   class SetupCommand
     include CLI::Output
+    include CLI::Project
 
     DEFAULT_HOST = "https://flare.am"
     TIMEOUT_SECONDS = 300 # 5 minutes
+    CLIENT_READ_TIMEOUT = 1
+
+    class AuthorizationDenied < StandardError; end
 
     INITIALIZER_CONTENT = <<~RUBY
       # frozen_string_literal: true
@@ -109,9 +115,7 @@ module Flare
     # --- Auth ---
 
     def authenticate
-      env_path = File.join(Dir.pwd, ".env")
-
-      if !@force && File.exist?(env_path) && File.read(env_path).match?(/^FLARE_KEY=.+/)
+      if !@force && key_in_dotenv?
         puts "#{checkmark} FLARE_KEY already set in .env, skipping auth."
         puts "  Run with --force to re-authenticate."
         return
@@ -139,7 +143,12 @@ module Flare
       puts
       puts "Waiting for authorization (up to 5 minutes)..."
 
-      auth_code = wait_for_callback(server, state, TIMEOUT_SECONDS)
+      begin
+        auth_code = wait_for_callback(server, state, TIMEOUT_SECONDS)
+      rescue AuthorizationDenied => e
+        puts "Authorization failed: #{e.message}"
+        exit 1
+      end
 
       unless auth_code
         puts "Timed out waiting for authorization."
@@ -152,50 +161,59 @@ module Flare
       server&.close
     end
 
+    # Waits for flare-web to redirect the browser back with a code. Anything
+    # else that reaches the port (a stray request, a wrong or missing state,
+    # a connection that never sends a request) gets a response and is
+    # skipped, so only a matching callback ends the wait.
     def wait_for_callback(server, expected_state, timeout)
       deadline = Time.now + timeout
 
       while Time.now < deadline
-        readable = IO.select([server], nil, nil, 1)
-        next unless readable
+        next unless IO.select([server], nil, nil, 1)
 
-        client = server.accept
-        request_line = client.gets
+        code = handle_callback(server.accept, expected_state)
+        return code if code
+      end
 
-        unless request_line&.start_with?("GET /callback")
-          client.print "HTTP/1.1 404 Not Found\r\nConnection: close\r\n\r\n"
-          client.close
-          next
-        end
+      nil
+    end
 
-        # Read remaining headers (required by HTTP spec)
-        while (line = client.gets) && line != "\r\n"; end
-
-        params = parse_query_string(request_line)
-        returned_state = params["state"]
-        code = params["code"]
-        error = params["error"]
-
-        if error
-          client.print http_response(error_page(error))
-          client.close
-          return nil
-        elsif returned_state != expected_state
-          client.print http_response(error_page("State mismatch. Please try again."))
-          client.close
-          return nil
-        elsif code.nil? || code.empty?
-          client.print http_response(error_page("No authorization code received."))
-          client.close
-          return nil
-        else
-          client.print http_response(success_page)
-          client.close
-          return code
+    # Returns the code, nil to keep waiting, or raises AuthorizationDenied
+    # when flare-web reports an error for this state.
+    def handle_callback(client, expected_state)
+      request_line = Timeout.timeout(CLIENT_READ_TIMEOUT) do
+        client.gets.tap do
+          # Read remaining headers (required by HTTP spec)
+          while (header = client.gets) && header != "\r\n"; end
         end
       end
 
+      unless request_line&.start_with?("GET /callback")
+        client.print "HTTP/1.1 404 Not Found\r\nConnection: close\r\n\r\n"
+        return nil
+      end
+
+      params = parse_query_string(request_line)
+      code = params["code"]
+      error = params["error"]
+
+      if params["state"] != expected_state
+        client.print http_response(error_page("State mismatch. Please try again."))
+        nil
+      elsif error
+        client.print http_response(error_page(error))
+        raise AuthorizationDenied, error
+      elsif code.nil? || code.empty?
+        client.print http_response(error_page("No authorization code received."))
+        nil
+      else
+        client.print http_response(success_page)
+        code
+      end
+    rescue Timeout::Error, IOError, SystemCallError
       nil
+    ensure
+      client.close
     end
 
     def parse_query_string(request_line)
@@ -205,6 +223,8 @@ module Flare
       query = URI(path).query
       return {} unless query
       URI.decode_www_form(query).to_h
+    rescue URI::InvalidURIError, ArgumentError
+      {}
     end
 
     def http_response(body)
@@ -250,9 +270,12 @@ module Flare
       puts "  3. Print token"
       print "Choose (1/2/3): "
 
-      choice = $stdin.gets&.strip
-
-      case choice
+      case $stdin.gets&.strip
+      when nil
+        # Closed stdin (a script, CI, a coding agent) can't answer. Asking again
+        # would never end and lose the token we just got, so show it.
+        puts
+        print_token(token)
       when "1"
         @saved_to_dotenv = true
         save_to_dotenv(token)
@@ -354,7 +377,7 @@ module Flare
       contents = File.read(gitignore_path)
       entries_to_add = []
 
-      entries_to_add << ".env" if @saved_to_dotenv && !contents.match?(/^\.env$/)
+      entries_to_add << ".env" if (@saved_to_dotenv || key_in_dotenv?) && !env_ignored?(contents)
       entries_to_add << "flare.sqlite3*" unless contents.include?("flare.sqlite3*")
 
       return if entries_to_add.empty?

data/lib/flare/cli/status_command.rb

@@ -1,11 +1,13 @@
 # frozen_string_literal: true
 
 require_relative "output"
+require_relative "project"
 require_relative "../version"
 
 module Flare
   class StatusCommand
     include CLI::Output
+    include CLI::Project
 
     def run
       puts bold("Flare v#{VERSION}")
@@ -30,9 +32,10 @@ module Flare
       if ENV["FLARE_KEY"] && !ENV["FLARE_KEY"].empty?
         green("set via ENV")
       else
-        env_path = File.join(Dir.pwd, ".env")
-        if File.exist?(env_path) && File.read(env_path).match?(/^FLARE_KEY=.+/)
+        if key_in_dotenv?
           green("set in .env")
+        elsif credentials_exist?
+          dim("not in ENV or .env (may be in Rails credentials)")
         else
           red("not configured")
         end

data/lib/flare/cli.rb

@@ -8,6 +8,9 @@ module Flare
       "setup" => "Authenticate and configure Flare for this project",
       "doctor" => "Check your Flare setup for issues",
       "status" => "Show current Flare configuration",
+      "requests" => "List recent requests from local development spans",
+      "request" => "Show one request's timeline from local development spans",
+      "nplus1" => "Find queries repeated within recent requests from local development spans",
       "version" => "Print the Flare version",
       "help" => "Show this help message",
     }.freeze
@@ -26,6 +29,15 @@ module Flare
       when "status"
         require_relative "cli/status_command"
         StatusCommand.new.run
+      when "requests"
+        require_relative "cli/requests_command"
+        RequestsCommand.new(argv.drop(1)).run
+      when "request"
+        require_relative "cli/request_command"
+        RequestCommand.new(argv.drop(1)).run
+      when "nplus1"
+        require_relative "cli/nplus1_command"
+        Nplus1Command.new(argv.drop(1)).run
       when "version", "-v", "--version"
         puts "flare #{Flare::VERSION}"
       when "help", nil, "-h", "--help"

data/lib/flare/client_headers.rb

@@ -8,7 +8,8 @@ module Flare
   # Single source of truth for the headers that identify this client and its
   # version to the Flare API. The server parses the gem version out of the
   # User-Agent ("Flare Ruby/X.Y.Z") to gate version-dependent features, and
-  # uses the X-Client-* headers to build a per-client picture.
+  # uses the X-Client-* headers to build a per-client picture. X-Client-Revision
+  # (when one resolves, see Configuration#revision) marks deploys on the charts.
   #
   # Safe to send on any request that targets the Flare API (metrics POST,
   # rules GET, trace-notify POST). Do NOT send these on the presigned R2 blob
@@ -19,8 +20,8 @@ module Flare
   module ClientHeaders
     USER_AGENT = "Flare Ruby/#{Flare::VERSION}"
 
-    def self.to_h
-      {
+    def self.to_h(configuration = Flare.configuration)
+      headers = {
         "User-Agent"                => USER_AGENT,
         "X-Client-Language"         => "ruby",
         "X-Client-Language-Version" => RUBY_VERSION,
@@ -28,6 +29,9 @@ module Flare
         "X-Client-Pid"              => Process.pid.to_s,
         "X-Client-Hostname"         => hostname
       }
+      revision = configuration.revision
+      headers["X-Client-Revision"] = revision if revision
+      headers
     end
 
     def self.hostname

data/lib/flare/configuration.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "http_metrics_config"
+require_relative "revision"
 
 module Flare
   class Configuration
@@ -50,6 +51,7 @@ module Flare
       @ignore_request = ->(request) { false }
       @subscribe_patterns = DEFAULT_SUBSCRIBE_PATTERNS.dup
       @debug = ENV["FLARE_DEBUG"] == "1"
+      @revision = ENV["FLARE_REVISION"]
       @http_metrics_config = HttpMetricsConfig::DEFAULT
 
       # Environment-based defaults:
@@ -103,6 +105,24 @@ module Flare
       yield @http_metrics_config
     end
 
+    # The deployed revision, usually a git SHA, sent so Flare can mark deploys.
+    # Defaults to FLARE_REVISION; when neither is set, the first read asks
+    # Flare::Revision (platform variables, a REVISION file, then git).
+    def revision
+      return @revision if @revision_resolved
+
+      # Flag after the value, so a racing reader never sees the unresolved one.
+      # Two first readers may both resolve; they get the same answer.
+      @revision = Revision.resolve(@revision)
+      @revision_resolved = true
+      @revision
+    end
+
+    def revision=(value)
+      @revision_resolved = false
+      @revision = value
+    end
+
     private
 
     def rails_development?

data/lib/flare/export_filter.rb

@@ -0,0 +1,273 @@
+# frozen_string_literal: true
+
+require "active_support"
+require "active_support/parameter_filter"
+require "set"
+require "uri"
+
+require_relative "sql_mask"
+require_relative "store_statement"
+require_relative "utf8"
+
+module Flare
+  # Applies the app's filter_parameters and masks SQL values in span names and
+  # attributes before a trace leaves the process. Attributes that name the code
+  # or describe the request's shape are kept as they are, because the trace view
+  # and trace rules read them. Everything else is treated as possibly holding a
+  # value the app wouldn't want sent.
+  class ExportFilter
+    FILTERED = "[FILTERED]"
+    MAX_TEXT_BYTES = SqlMask::MAX_BYTES
+
+    # Applied even if the app's list is empty or was trimmed. Rails' generated
+    # list, plus the names credentials go by in URLs and headers.
+    DEFAULT_FILTERS = [
+      :passw, :email, :secret, :token, :_key, :crypt, :salt, :certificate, :otp, :ssn, :cvv, :cvc,
+      /api.?key/i, /authoriz/i, /oauth/i, /\Aauth\z/i, /cookie/i, /session/i, /credential/i, /signature/i,
+      /jwt/i, /bearer/i, /pwd/i, /\Apass\z/i, /\Akey\z/i, /\Asig\z/i, /\Acode\z/i
+    ].freeze
+
+    KEPT = %w[
+      name identifier layout count cache_hits record_count class_name
+      mailer action message_id hit exist store
+      http.method http.request.method http.status_code http.response.status_code
+      http.scheme url.scheme http.route http.user_agent user_agent.original
+      db.system db.system.name db.name db.namespace
+      db.sql.table db.collection.name db.redis.database_index
+      exception.type server.port net.peer.port
+    ].to_set.freeze
+    KEPT_PREFIX = /\A(?:code|messaging|flare|otel)\./
+
+    # What these hold can't be sorted into safe and unsafe parts: message bodies
+    # and recipients, job arguments, request and exception contents.
+    OPAQUE = %w[
+      to from cc bcc reply_to subject mail
+      args arguments params parameters headers cookies body payload request response env session
+      exception exception_object exception.message exception.stacktrace
+    ].to_set.freeze
+    OPAQUE_PREFIX = /\Aemail\./
+
+    OPERATIONS = %w[db.operation db.operation.name].to_set.freeze
+    STATEMENTS = %w[db.statement db.query.text db.query db.sql sql statement query].to_set.freeze
+    # A leading comment or parenthesis counts, since a statement can start with one.
+    SQL_TEXT = %r{\A[\s(]*(?:/\*|--|(?:select|insert|update|delete|replace|merge|with|set|create|alter|drop|truncate|grant|revoke|explain|describe|show|call|exec|execute|values|copy|pragma|vacuum|lock|begin|prepare)\b)}i
+    # With no system to go on, only statements that clearly read as queries get
+    # SQL masking, since it keeps bare words like the arguments of SET session:x y.
+    QUERY_TEXT = /\A[\s(]*(?:select|insert|update|delete|replace|merge|with|explain|values)\b/i
+    STRUCTURED_TEXT = /\A\s*[{\[]/
+
+    URLS = %w[http.url url.full url.path http.target http.referer url.original].to_set.freeze
+    HOSTS = %w[http.host server.address net.peer.name].to_set.freeze
+    USERINFO = /\A.*@/m
+    MONGO = /mongo/i
+
+    URL_START = %r{\A((?:[a-z][a-z0-9+.-]*:)?//)([^/?#]*)(.*)\z}im
+    NUMERIC_PORT = /\A(?:\[[^\]]*\]|[^:]*)(?::\d*)?\z/
+    SCHEMELESS_USERINFO = %r{\A[^/?#]+@}
+    PATH_USERINFO = %r{(?<=/|\A)[^/@]+@[^/]*}
+
+    # One scan over free text, leftmost first, so what a URL contains is never read
+    # as a key and value. key or quoted_key holds a pair's name.
+    TEXT_TOKEN = %r{
+      (?<url>(?<!\w)(?:(?<![.+\-])[a-z][a-z0-9+.-]*+:)?//[^\s'"<>]*+(?:['"](?>[^\s<>@]{0,256})@[^\s<>]*+)?)
+      |(?<auth>(?<!\w)(?:bearer\s+\S++|basic\s+[A-Za-z0-9+/=]{8,}))
+      |(?:
+        (?<!\\)\\*+(?<quote>["'])(?<quoted_key>[\w.\-\[\]%]++)\\*+\k<quote>\]?
+        |(?<![\w.\-\[\]%])(?<key>[\w.\-\[\]%]++)
+      )\s*+(?:=>|=|:)\s*+
+    }xi
+    # A value longer than this is masked rather than judged on part of it.
+    VALUE_WINDOW = 256
+    VALUE = /\A[^\s&;,]*+/
+    QUOTED_VALUE = /\A\\*+(?:["']|\z)/
+    NESTED_VALUE = %r{=|%3d|//|%2f%2f|@|%40}i
+
+    class << self
+      # Built on use, and rebuilt if the list changes, because initializers and
+      # engines can add to filter_parameters at any point during boot.
+      def current
+        filters = app_filters
+        cached = @current
+        return cached.last if cached && cached.first == filters
+
+        filter = new(filters)
+        @current = [filters.dup.freeze, filter]
+        filter
+      end
+
+      private
+
+      def app_filters
+        return [] unless defined?(Rails) && Rails.respond_to?(:application) && Rails.application
+
+        Array(Rails.application.config.filter_parameters)
+      rescue StandardError
+        []
+      end
+    end
+
+    def initialize(filters = [])
+      @parameter_filter = ActiveSupport::ParameterFilter.new(DEFAULT_FILTERS + filters)
+    end
+
+    def attributes(attrs)
+      return {} if attrs.nil?
+
+      system = attrs["db.system"] || attrs["db.system.name"]
+      attrs.each_with_object({}) { |(name, value), out| out[name] = attribute(UTF8.scrub(name.to_s), value, system) }
+    end
+
+    def name(value)
+      return value unless value.is_a?(String)
+
+      free_text(clean(value))
+    rescue StandardError
+      FILTERED
+    end
+
+    private
+
+    def attribute(name, value, system)
+      return value if KEPT.include?(name) || KEPT_PREFIX.match?(name)
+      return FILTERED if OPAQUE.include?(name) || OPAQUE_PREFIX.match?(name)
+
+      case value
+      when String then text_attribute(name, value, system)
+      when Array then value.map { |item| attribute(name, item, system) }
+      else param_kept?(name, value) ? value : FILTERED
+      end
+    rescue StandardError
+      # A value that can't be processed doesn't go out.
+      FILTERED
+    end
+
+    def text_attribute(name, value, system)
+      return statement(value, system) if STATEMENTS.include?(name)
+      return SqlMask.operation_word(value) || SqlMask::PLACEHOLDER if OPERATIONS.include?(name)
+
+      text = clean(value)
+      if URLS.include?(name) then url(text)
+      elsif HOSTS.include?(name) then text.sub(USERINFO, "")
+      elsif name == "url.query" then query_string(text)
+      elsif name == "key" then StoreStatement.masked_key(text)
+      elsif param_kept?(name, text) then free_text(text)
+      else FILTERED
+      end
+    end
+
+    def clean(value)
+      UTF8.scrub(value.bytesize > MAX_TEXT_BYTES ? value.byteslice(0, MAX_TEXT_BYTES) : value)
+    end
+
+    def statement(text, system)
+      return StoreStatement.redis(text) if StoreStatement.redis_system?(system)
+      return StoreStatement.mongo(text) if MONGO.match?(system.to_s)
+
+      return command_only(clean(text)) unless SqlMask.sql_system?(system)
+
+      masked = SqlMask.mask(text, system)
+      return SqlMask::PLACEHOLDER if masked.empty?
+      return command_only(masked) if system.to_s.empty? && !QUERY_TEXT.match?(masked)
+
+      masked
+    end
+
+    def command_only(text)
+      command = SqlMask.command_word(text)
+      command ? "#{command} #{SqlMask::PLACEHOLDER}" : SqlMask::PLACEHOLDER
+    end
+
+    def url(text)
+      match = URL_START.match(text)
+      return without_fragment_and_query(text.sub(SCHEMELESS_USERINFO, "")) unless match
+
+      scheme, authority, rest = match.captures
+      if authority.include?("@")
+        authority = authority.sub(USERINFO, "")
+      elsif !NUMERIC_PORT.match?(authority)
+        return "#{scheme}#{FILTERED}"
+      end
+
+      "#{scheme}#{authority}#{without_fragment_and_query(rest)}"
+    end
+
+    def without_fragment_and_query(text)
+      base, query = text.split("#", 2).first.to_s.split("?", 2)
+      base = base.to_s.gsub(PATH_USERINFO, FILTERED)
+      query ? "#{base}?#{query_string(query)}" : base
+    end
+
+    def query_string(text)
+      text.gsub(/[^&;]+/) { |part| pair(part) }
+    end
+
+    def pair(part)
+      key, value = part.split("=", 2)
+      return FILTERED if value.nil?
+
+      pair_kept?(key, value) ? part : "#{key}=#{FILTERED}"
+    end
+
+    def pair_kept?(key, value)
+      !NESTED_VALUE.match?(value) && param_kept?(URI.decode_www_form_component(key), value)
+    end
+
+    # user[password]=x is checked as nested params, so filters written as
+    # "user.password" apply to it too.
+    def param_kept?(key, value)
+      unless key.include?("[")
+        result = @parameter_filter.filter_param(key, value)
+        return result.equal?(value) || result == value
+      end
+
+      path = key.split(/[\[\]]+/).reject(&:empty?)
+      nested = path.reverse.inject(value) { |inner, part| { part => inner } }
+      @parameter_filter.filter(nested) == nested
+    end
+
+    # Text with no known meaning: custom notification payloads, span names. Masks
+    # more than it needs to rather than guess where a value ends.
+    def free_text(text)
+      return FILTERED if STRUCTURED_TEXT.match?(text)
+      # What's left of SQL is still read for pairs, since a word like DROP can also
+      # start ordinary text.
+      text = SqlMask.mask(text) if SQL_TEXT.match?(text)
+
+      out = +""
+      position = 0
+      while (match = TEXT_TOKEN.match(text, position))
+        out << text[position...match.begin(0)]
+        position = match.end(0)
+
+        if match[:url] then out << text_url(match[:url])
+        elsif match[:auth] then out << match[:auth].split(/\s+/).first << " " << FILTERED
+        else
+          out << match[0]
+          value = text[position, VALUE_WINDOW + 1][VALUE]
+          next if value.length <= VALUE_WINDOW && pair_kept?(match[:key] || match[:quoted_key], value)
+
+          out << FILTERED
+          position = sensitive_value_end(text, position)
+        end
+      end
+      out << text[position..]
+    end
+
+    # A quote with an @ after it can't be read as a URL's parts, so none of it is kept.
+    def text_url(found)
+      scheme = found[/\A[^:\/]+(?=:)/]
+      return FILTERED if scheme && !param_kept?(scheme, found)
+
+      found.match?(/['"]/) ? "#{scheme}#{":" if scheme}//#{FILTERED}" : url(found)
+    end
+
+    # A quoted value may hold escapes and line breaks, so it masks everything after
+    # it. Otherwise the line ends it, which covers multi-word values like cookie
+    # lists.
+    def sensitive_value_end(text, position)
+      return text.length if QUOTED_VALUE.match?(text[position, VALUE_WINDOW])
+
+      text.index("\n", position) || text.length
+    end
+  end
+end

data/lib/flare/filtering_span_processor.rb

@@ -82,6 +82,15 @@ module Flare
         complete: owner_finished || sampled_completion_span?(span_data),
         delay: owner_finished ? @marked_trace_grace_period : 0
       )
+    rescue StandardError => e
+      # The SDK calls processors without a rescue, so a bug here would raise
+      # into the app's request or job. Count every failure, warn once
+      # per process (keyed by pid so forked workers still warn).
+      @exception_count.increment
+      return if @on_finish_error_warned_pid == $$
+
+      @on_finish_error_warned_pid = $$
+      @logger.warn("[Flare::FilteringSpanProcessor] on_finish failed: #{e.class}: #{e.message}")
     end
 
     def force_flush(timeout: nil)
@@ -136,6 +145,8 @@ module Flare
 
     def enqueue(span_data, complete:, delay: 0)
       @mutex.synchronize do
+        return if @stopped
+
         trace_id = span_data.trace_id
         @trace_order << trace_id unless @pending_by_trace.key?(trace_id)
         @pending_by_trace[trace_id] ||= []
@@ -323,6 +334,9 @@ module Flare
       now = monotonic_now
       ready_trace_ids = @delayed_ready_by_trace.select { |_, ready_at| ready_at <= now }.keys
       ready_trace_ids.each do |trace_id|
+        # Overflow may have evicted the whole batch, so mark_trace_ready
+        # would not clear the entry and next_wait_timeout would return 0 forever.
+        @delayed_ready_by_trace.delete(trace_id)
         mark_trace_ready(trace_id)
         @marker.unmark(trace_id)
       end

data/lib/flare/http_transport.rb

@@ -55,6 +55,10 @@ module Flare
       http.open_timeout = effective_timeout(@open_timeout, deadline.remaining)
       http.read_timeout = effective_timeout(@read_timeout, deadline.remaining)
       http.write_timeout = effective_timeout(@write_timeout, deadline.remaining) if http.respond_to?(:write_timeout=)
+      # Net::HTTP silently resends a GET or PUT once after a read timeout or
+      # dropped connection, with a fresh timeout, so a slow server took twice
+      # the caller's budget. Callers decide when to try again.
+      http.max_retries = 0
 
       req = klass.new(uri.request_uri == "" ? "/" : uri.request_uri)
       headers.each { |k, v| req[k] = v }