coolhand 0.7.0 → 0.9.0

data/lib/coolhand/log_queue.rb

@@ -0,0 +1,179 @@
+# frozen_string_literal: true
+
+module Coolhand
+  # Runs log-shipping work on background threads so a slow or unreachable Coolhand backend can't
+  # add latency to the host app's own LLM calls.
+  #
+  # Work is spread over two lanes, each with its own bounded queue and worker thread: `:default`
+  # for the one-log-per-intercepted-call sends, and `:batch` for whole-batch jobs (download +
+  # one send per item) that can run for minutes. Keeping them apart stops a long batch from
+  # delaying — or, once the queue fills, evicting — the real-time logs.
+  #
+  # Each queue is bounded (oldest job dropped when full), restarts itself in a forked child, and
+  # is flushed at process exit. Work runs inline instead when `config.async_logging` is false,
+  # when `config.debug_mode` is on (debug output should appear in order), or when the caller is
+  # already a worker thread (a queued job's own sends don't re-enter a queue).
+  module LogQueue
+    MAX_QUEUE_SIZE = 1000
+    DEFAULT_FLUSH_TIMEOUT = 5
+
+    # One bounded FIFO plus the thread that drains it.
+    class Lane
+      attr_reader :thread
+
+      def initialize
+        @mutex = Mutex.new
+        @wakeup = ConditionVariable.new
+        @idle = ConditionVariable.new
+        @jobs = []
+        @thread = nil
+        @pid = Process.pid
+        @busy = false
+      end
+
+      def enqueue(job)
+        @mutex.synchronize do
+          restart_after_fork
+          drop_oldest if @jobs.size >= MAX_QUEUE_SIZE
+          @jobs << job
+          ensure_worker
+          @wakeup.signal
+        end
+      end
+
+      # True once every queued job has finished, false if the timeout elapsed first.
+      def flush(deadline)
+        @mutex.synchronize do
+          # A forked child's copy of the queue belongs to the parent's worker; nothing to wait on.
+          return true if @pid != Process.pid
+          # A dead worker will never drain the queue, so don't wait on it.
+          return @jobs.empty? unless @thread&.alive?
+
+          while @jobs.any? || @busy
+            remaining = deadline - Process.clock_gettime(Process::CLOCK_MONOTONIC)
+            return false unless remaining.positive?
+
+            @idle.wait(@mutex, remaining)
+          end
+          true
+        end
+      end
+
+      def reset!
+        thread = nil
+        @mutex.synchronize do
+          thread = @thread
+          @jobs.clear
+          @thread = nil
+          @busy = false
+          @wakeup.broadcast
+          @idle.broadcast
+        end
+        thread&.join(1)
+        thread&.kill if thread&.alive?
+      end
+
+      private
+
+      def drop_oldest
+        @jobs.shift
+        Coolhand.log "⚠️ Log queue full (#{MAX_QUEUE_SIZE}); dropping the oldest pending log"
+      end
+
+      # A forked child inherits the queue's memory but not its worker thread.
+      def restart_after_fork
+        return if @pid == Process.pid
+
+        @pid = Process.pid
+        @jobs = []
+        @thread = nil
+        @busy = false
+      end
+
+      def ensure_worker
+        return if @thread&.alive?
+
+        @thread = Thread.new { work }
+        @thread.report_on_exception = false
+      end
+
+      def work
+        loop do
+          job = next_job
+          break unless job
+
+          begin
+            run(job)
+          ensure
+            @mutex.synchronize do
+              @busy = false
+              @idle.broadcast
+            end
+          end
+        end
+      end
+
+      def next_job
+        @mutex.synchronize do
+          @wakeup.wait(@mutex) while @jobs.empty? && @thread == Thread.current
+          return nil unless @thread == Thread.current
+
+          @busy = true
+          @jobs.shift
+        end
+      end
+
+      def run(job)
+        job.call
+      rescue StandardError => e
+        Coolhand.log "❌ Error in background log job: #{e.message}"
+      end
+    end
+
+    LANES = { default: Lane.new, batch: Lane.new }.freeze
+
+    @at_exit_mutex = Mutex.new
+    @at_exit_registered = false
+
+    class << self
+      def submit(lane: :default, &job)
+        return yield unless async?
+
+        register_at_exit
+        LANES.fetch(lane).enqueue(job)
+        nil
+      end
+
+      # Blocks until every queued job has finished or the timeout elapses. Returns true when
+      # every lane drained in time.
+      def flush(timeout = DEFAULT_FLUSH_TIMEOUT)
+        deadline = Process.clock_gettime(Process::CLOCK_MONOTONIC) + timeout
+        LANES.values.map { |lane| lane.flush(deadline) }.all?
+      end
+
+      # Testing-only: discard queued work and stop the workers.
+      def reset!
+        LANES.each_value(&:reset!)
+      end
+
+      private
+
+      def async?
+        Coolhand.configuration.async_logging && !Coolhand.configuration.debug_mode && !worker_thread?
+      end
+
+      def worker_thread?
+        LANES.each_value.any? { |lane| lane.thread == Thread.current }
+      end
+
+      def register_at_exit
+        @at_exit_mutex.synchronize do
+          return if @at_exit_registered
+
+          @at_exit_registered = true
+          at_exit { flush }
+        end
+      end
+    end
+  end
+end

data/lib/coolhand/log_service.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require_relative "api_service"
+require_relative "pagination"
+require_relative "read_query"
+
+module Coolhand
+  # Rows stay plain Symbol-keyed Hashes so a field the server adds later is not dropped in transit.
+  LogSearchResult = Struct.new(:logs, :pagination, keyword_init: true)
+
+  # Reads logs back out of Coolhand. The write side is {LoggerService}. Requires the client's
+  # **private** key. See docs/log-search.md.
+  class LogService < ApiService
+    include ReadQuery
+
+    ERROR_NOUN = "Log"
+    BLANK_ID_MESSAGE = "get_log: id must be a non-empty log hashid"
+
+    def initialize
+      super("v2/llm_request_logs")
+    end
+
+    # Filters, cost ordering, error semantics and server behaviour: docs/log-search.md.
+    def search_logs(template_id: nil, workload_id: nil, system_prompt_contains: nil, user_prompt_contains: nil,
+      model: nil, source_api: nil, source_api_result: nil, source_application: nil, project_path: nil,
+      unmatched_only: nil, days_back: nil, since: nil, until: nil, min_cost: nil, order: nil,
+      include_prompts: nil, include_total: nil, sort: nil, page: nil, per: nil)
+      query = {
+        template_id: template_id,
+        workload_id: workload_id,
+        system_prompt_contains: system_prompt_contains,
+        user_prompt_contains: user_prompt_contains,
+        model: model,
+        source_api: source_api,
+        source_api_result: source_api_result,
+        source_application: source_application,
+        project_path: project_path,
+        unmatched_only: unmatched_only,
+        days_back: days_back,
+        **window_params(since, binding.local_variable_get(:until)),
+        min_cost: min_cost,
+        order: order,
+        include_prompts: include_prompts,
+        include_total: include_total,
+        "q[s]": sort,
+        page: page,
+        per: per
+      }.compact
+
+      fetch_list(query, LogSearchResult, :logs, page: page, per: per)
+    end
+
+    # The full log, with `cost` and `cost_breakdown`. Both are nil when the log has no tokens or its
+    # model has no pricing.
+    def get_log(id, section: nil, max_chars: nil, search_query: nil, include_thinking: nil)
+      query = { section: section, max_chars: max_chars, search_query: search_query,
+                include_thinking: include_thinking }.compact
+      get_json(resource_url(id, BLANK_ID_MESSAGE, query), ERROR_NOUN)
+    end
+  end
+end

data/lib/coolhand/logger_service.rb

@@ -15,24 +15,8 @@ module Coolhand
     # Helper method for forwarding webhook data to Coolhand
     def forward_webhook(webhook_body:, source:, event_type: nil, headers: {}, **options)
       # Validate required parameters
-      unless Coolhand.required_field?(webhook_body)
-        error_msg = "webhook_body is required and cannot be nil or empty"
-        if Coolhand.configuration.silent
-          puts "COOLHAND WARNING: #{error_msg}"
-          return false
-        else
-          raise ArgumentError, error_msg
-        end
-      end
-
-      unless Coolhand.required_field?(source)
-        error_msg = "source is required and cannot be nil or empty"
-        if Coolhand.configuration.silent
-          puts "COOLHAND WARNING: #{error_msg}"
-          return false
-        else
-          raise ArgumentError, error_msg
-        end
+      { webhook_body: webhook_body, source: source }.each do |name, value|
+        return reject_webhook("#{name} is required and cannot be nil or empty") unless Coolhand.required_field?(value)
       end
 
       # Auto-generate required fields unless provided
@@ -55,6 +39,14 @@ module Coolhand
 
     private
 
+    # Silent mode warns and drops the webhook; otherwise the caller gets the error.
+    def reject_webhook(error_msg)
+      raise ArgumentError, error_msg unless Coolhand.configuration.silent
+
+      puts "COOLHAND WARNING: #{error_msg}"
+      false
+    end
+
     def build_webhook_url(source, event_type)
       base = "webhook://#{source}"
       event_type ? "#{base}/#{event_type}" : base

data/lib/coolhand/net_http_interceptor.rb

@@ -4,8 +4,6 @@ require "stringio"
 
 module Coolhand
   module NetHttpInterceptor
-    include BaseInterceptor
-
     # Response streaming interceptor nested under NetHttpInterceptor
     module ResponseInterceptor
       def read_body(dest = nil, &block)
@@ -48,13 +46,12 @@ module Coolhand
           Net::HTTPResponse.prepend(ResponseInterceptor)
 
           @patched = true
-          Coolhand.log "🔗 Net::HTTP interceptor patched"
         rescue StandardError
           # Roll back this call's hold — it never actually took effect, so it must not count
           # toward the refcount or a legitimate later unpatch! would underflow against it. This
           # branch only runs when @patched was false on entry (see `next if @patched` above), so
           # forcing it back to false here is correct regardless of which line above raised —
-          # including a failure in the log call itself, after prepend already succeeded.
+          # including a failure in the second prepend, after the first already succeeded.
           @patch_count -= 1
           @patched = false
           raise
@@ -70,7 +67,7 @@ module Coolhand
         next if @patch_count.positive? || !@patched
 
         @patched = false
-        Coolhand.log "🔌 Faraday monitoring disabled ..."
+        Coolhand.log "🔌 Net::HTTP interceptor unpatched (capture stopped)"
       end
     end
 
@@ -93,7 +90,7 @@ module Coolhand
       active = (Thread.current[:coolhand_active_requests] ||= {}.compare_by_identity)
       return super if active.key?(self)
 
-      url = capturable_url(req)
+      url = Helpers.capturable_url(self, req)
       return super unless url
 
       # Capture body before setting the guard — if this raises we skip logging cleanly
@@ -102,7 +99,7 @@ module Coolhand
       # from being attempted — this gem must never be the reason the host
       # app's actual LLM call doesn't happen.
       captured_body = begin
-        capture_request_body(req, body)
+        Helpers.capture_request_body(req, body)
       rescue StandardError => e
         Coolhand.log "❌ Error capturing request body: #{e.message}"
         nil
@@ -129,9 +126,9 @@ module Coolhand
         body_content = Thread.current[:coolhand_stream_buffer] || response&.body
         body_content = body_content.dup.force_encoding("UTF-8") if body_content.is_a?(String)
         status_code = response.respond_to?(:code) ? response.code.to_i : nil
-        response_body = parse_json(body_content)
+        response_body = BaseInterceptor.parse_json(body_content)
       rescue StandardError => e
-        status_code = extract_status_from_exception(e)
+        status_code = Helpers.extract_status_from_exception(e)
         response_body = { "error" => { "class" => e.class.name, "message" => e.message } }
         raise
       ensure
@@ -141,13 +138,15 @@ module Coolhand
         end_time = Time.now
         duration_ms = ((end_time - start_time) * 1000).round(2)
 
-        send_complete_request_log(
+        # Read here on the calling thread: the log worker thread has no access to our thread-locals.
+        BaseInterceptor.send_complete_request_log(
+          declared: DeclaredContext.current,
           request_id: request_id,
           method: req.method,
           url: url,
-          request_headers: sanitize_headers(req),
+          request_headers: BaseInterceptor.sanitize_headers(req),
           request_body: captured_body,
-          response_headers: sanitize_headers(response),
+          response_headers: BaseInterceptor.sanitize_headers(response),
           response_body: response_body,
           status_code: status_code,
           start_time: start_time,
@@ -160,164 +159,171 @@ module Coolhand
       response
     end
 
-    private
-
-    def should_capture?
-      return true if Coolhand.configuration.debug_mode
+    # Stateless helpers for #request. They live in their own namespaced module (not on the
+    # prepended module itself) so the only method NetHttpInterceptor adds to Net::HTTP is
+    # `request` — generically named helpers like `intercept?` would otherwise pollute
+    # Net::HTTP and could collide with, or be shadowed by, other code.
+    module Helpers
+      module_function
 
-      override = Thread.current[:coolhand_capture_override]
-      return override unless override.nil?
+      def should_capture?
+        return true if Coolhand.configuration.debug_mode
 
-      Coolhand.configuration.capture
-    end
+        override = Thread.current[:coolhand_capture_override]
+        return override unless override.nil?
 
-    def capture_request_body(req, body)
-      # Check content-type before touching body_stream at all — for a binary
-      # upload (multipart/form-data, audio/*, etc.) this avoids reading the
-      # stream into memory a second time just to build a log entry no one
-      # can read anyway.
-      return skipped_capture_marker(req, "non_json_content_type") if binary_upload?(req)
-
-      content = body || req.body
-      if content.nil? && req.respond_to?(:body_stream) && req.body_stream
-        content = req.body_stream.read
-        req.body_stream = StringIO.new(content)
+        Coolhand.configuration.capture
       end
-      return nil if content.nil?
 
-      cap_and_parse(content, req)
-    end
+      def capture_request_body(req, body)
+        # Check content-type before touching body_stream at all — for a binary
+        # upload (multipart/form-data, audio/*, etc.) this avoids reading the
+        # stream into memory a second time just to build a log entry no one
+        # can read anyway.
+        return skipped_capture_marker(req, "non_json_content_type") if binary_upload?(req)
+
+        content = body || req.body
+        if content.nil? && req.respond_to?(:body_stream) && req.body_stream
+          content = req.body_stream.read
+          req.body_stream = StringIO.new(content)
+        end
+        return nil if content.nil?
 
-    def binary_upload?(req)
-      content_type = req.respond_to?(:content_type) ? req.content_type : nil
-      content_type && !content_type.match?(/json/i)
-    end
+        cap_and_parse(content, req)
+      end
 
-    def cap_and_parse(content, req)
-      max_bytes = Coolhand.configuration.max_captured_body_bytes
-      if max_bytes && content.bytesize > max_bytes
-        return skipped_capture_marker(req, "body_too_large", size_bytes: content.bytesize, max_bytes: max_bytes)
+      def binary_upload?(req)
+        content_type = req.respond_to?(:content_type) ? req.content_type : nil
+        content_type && !content_type.match?(/json/i)
       end
 
-      parse_json(content)
-    end
+      def cap_and_parse(content, req)
+        max_bytes = Coolhand.configuration.max_captured_body_bytes
+        if max_bytes && content.bytesize > max_bytes
+          return skipped_capture_marker(req, "body_too_large", size_bytes: content.bytesize, max_bytes: max_bytes)
+        end
 
-    def skipped_capture_marker(req, reason, extra = {})
-      marker = { "_coolhand_capture_skipped" => reason }.merge(extra.transform_keys(&:to_s))
-      content_type = req.respond_to?(:content_type) ? req.content_type : nil
-      marker["content_type"] = content_type if content_type
-      marker
-    end
+        BaseInterceptor.parse_json(content)
+      end
 
-    def extract_status_from_exception(e)
-      return e.status if e.respond_to?(:status) && e.status.is_a?(Integer)
-      return e.response.status if e.respond_to?(:response) && e.response.respond_to?(:status)
+      def skipped_capture_marker(req, reason, extra = {})
+        marker = { "_coolhand_capture_skipped" => reason }.merge(extra.transform_keys(&:to_s))
+        content_type = req.respond_to?(:content_type) ? req.content_type : nil
+        marker["content_type"] = content_type if content_type
+        marker
+      end
 
-      match = e.message.to_s.match(/status[=:\s]+(\d{3})/)
-      match ? match[1].to_i : nil
-    end
+      def extract_status_from_exception(e)
+        return e.status if e.respond_to?(:status) && e.status.is_a?(Integer)
+        return e.response.status if e.respond_to?(:response) && e.response.respond_to?(:status)
 
-    def intercept?(url)
-      return false unless url && Coolhand.configuration.respond_to?(:intercept_addresses)
+        match = e.message.to_s.match(/status[=:\s]+(\d{3})/)
+        match ? match[1].to_i : nil
+      end
 
-      uri = safe_parse(url)
-      return false unless uri&.host
+      def intercept?(url)
+        return false unless url && Coolhand.configuration.respond_to?(:intercept_addresses)
 
-      return false if excluded_by_pattern?(uri)
+        uri = safe_parse(url)
+        return false unless uri&.host
 
-      host = uri.host.downcase.chomp(".")
-      path = uri.path.to_s
-      addresses = Coolhand.configuration.intercept_addresses
-      authorities = [host, "#{host}:#{uri.port}"]
-      return true if addresses.any? { |a| authorities.any? { |authority| address_matches?(authority, path, a) } }
+        return false if excluded_by_pattern?(uri)
 
-      return false unless google_api_host_configured?(addresses)
-      return false unless host == "googleapis.com" || host.end_with?(".googleapis.com")
+        host = uri.host.downcase.chomp(".")
+        path = uri.path.to_s
+        addresses = Coolhand.configuration.intercept_addresses
+        authorities = [host, "#{host}:#{uri.port}"]
+        return true if addresses.any? { |a| authorities.any? { |authority| address_matches?(authority, path, a) } }
 
-      Coolhand.configuration.intercept_path_patterns.any? { |p| path.include?(p) }
-    end
+        return false unless google_api_host_configured?(addresses)
+        return false unless host == "googleapis.com" || host.end_with?(".googleapis.com")
 
-    # The capture decision runs before the host's real request, so a bad config value (e.g. a
-    # non-array exclude_api_patterns) must degrade to "don't capture", never raise into the host.
-    def capturable_url(req)
-      url = build_url_for_request(self, req)
-      url if intercept?(url) && should_capture?
-    rescue StandardError => e
-      Coolhand.log "⚠️ Skipping capture, could not evaluate intercept rules: #{e.class}"
-      nil
-    end
+        Coolhand.configuration.intercept_path_patterns.any? { |p| path.include?(p) }
+      end
 
-    def excluded_by_pattern?(uri)
-      patterns = Coolhand.configuration.exclude_api_patterns
-      return false if patterns.nil? || patterns.empty?
+      # The capture decision runs before the host's real request, so a bad config value (e.g. a
+      # non-array exclude_api_patterns) must degrade to "don't capture", never raise into the host.
+      def capturable_url(http, req)
+        url = build_url_for_request(http, req)
+        url if intercept?(url) && should_capture?
+      rescue StandardError => e
+        Coolhand.log "⚠️ Skipping capture, could not evaluate intercept rules: #{e.class}"
+        nil
+      end
+
+      def excluded_by_pattern?(uri)
+        patterns = Coolhand.configuration.exclude_api_patterns
+        return false if patterns.nil? || patterns.empty?
 
-      path = uri.path.to_s
-      matched = patterns.find { |pattern| path.include?(pattern) }
-      if matched && Coolhand.configuration.debug_mode
-        Coolhand.log "🚫 Skipping capture for #{sanitize_url(uri.to_s)} (matched exclude_api_pattern: \"#{matched}\")"
+        path = uri.path.to_s
+        matched = patterns.find { |pattern| path.include?(pattern) }
+        if matched && Coolhand.configuration.debug_mode
+          Coolhand.log "🚫 Skipping capture for #{BaseInterceptor.sanitize_url(uri.to_s)} " \
+                       "(matched exclude_api_pattern: \"#{matched}\")"
+        end
+        !!matched
       end
-      !!matched
-    end
 
-    # intercept_path_patterns only ever applies to googleapis.com hosts, and only when the
-    # user still wants Google API traffic intercepted at all — otherwise overriding
-    # intercept_addresses to exclude Google hosts wouldn't actually stop Google API capture.
-    def google_api_host_configured?(addresses)
-      addresses.any? do |a|
-        a = a.to_s.downcase
-        a == "googleapis.com" || a.end_with?(".googleapis.com")
+      # intercept_path_patterns only ever applies to googleapis.com hosts, and only when the
+      # user still wants Google API traffic intercepted at all — otherwise overriding
+      # intercept_addresses to exclude Google hosts wouldn't actually stop Google API capture.
+      def google_api_host_configured?(addresses)
+        addresses.any? do |a|
+          a = a.to_s.downcase
+          a == "googleapis.com" || a.end_with?(".googleapis.com")
+        end
       end
-    end
 
-    # An intercept_addresses entry may optionally pin a port ("host:port") and/or anchor to a
-    # path prefix by embedding a "/" — e.g. "api.cohere.com/v2/chat" only matches requests to
-    # that host whose path starts with "/v2/chat", and "cognitiveservices.azure.com/openai/" only
-    # matches that multi-service Azure host's OpenAI paths, so unrelated endpoints on a shared
-    # host aren't swept in alongside the ones we mean to capture.
-    # The match is on a path *segment* boundary (trailing "/" on the pattern is optional and
-    # stripped before comparing), so "host.com/openai" matches "/openai" and "/openai/x" but not
-    # a same-prefix-but-different-segment path like "/openaiz".
-    def address_matches?(host, path, pattern)
-      host_pattern, sep, path_pattern = pattern.to_s.partition("/")
-      return host_matches?(host, host_pattern) if sep.empty?
-      return false unless host_matches?(host, host_pattern)
-
-      path_pattern = path_pattern.delete_suffix("/")
-      return true if path_pattern.empty?
-
-      prefix = "/#{path_pattern}"
-      path == prefix || path.start_with?("#{prefix}/")
-    end
+      # An intercept_addresses entry may optionally pin a port ("host:port") and/or anchor to a
+      # path prefix by embedding a "/" — e.g. "api.cohere.com/v2/chat" only matches requests to
+      # that host whose path starts with "/v2/chat", and "cognitiveservices.azure.com/openai/" only
+      # matches that multi-service Azure host's OpenAI paths, so unrelated endpoints on a shared
+      # host aren't swept in alongside the ones we mean to capture.
+      # The match is on a path *segment* boundary (trailing "/" on the pattern is optional and
+      # stripped before comparing), so "host.com/openai" matches "/openai" and "/openai/x" but not
+      # a same-prefix-but-different-segment path like "/openaiz".
+      def address_matches?(host, path, pattern)
+        host_pattern, sep, path_pattern = pattern.to_s.partition("/")
+        return host_matches?(host, host_pattern) if sep.empty?
+        return false unless host_matches?(host, host_pattern)
+
+        path_pattern = path_pattern.delete_suffix("/")
+        return true if path_pattern.empty?
+
+        prefix = "/#{path_pattern}"
+        path == prefix || path.start_with?("#{prefix}/")
+      end
 
-    # Host-boundary match: exact, or a dot-delimited suffix (case-insensitive).
-    # A single "*" in `pattern` matches exactly one host label, e.g.
-    # "bedrock-runtime.*.amazonaws.com" matches "bedrock-runtime.us-east-1.amazonaws.com".
-    def host_matches?(host, pattern)
-      pattern = pattern.to_s.downcase
-      return host == pattern || host.end_with?(".#{pattern}") unless pattern.include?("*")
+      # Host-boundary match: exact, or a dot-delimited suffix (case-insensitive).
+      # A single "*" in `pattern` matches exactly one host label, e.g.
+      # "bedrock-runtime.*.amazonaws.com" matches "bedrock-runtime.us-east-1.amazonaws.com".
+      def host_matches?(host, pattern)
+        pattern = pattern.to_s.downcase
+        return host == pattern || host.end_with?(".#{pattern}") unless pattern.include?("*")
 
-      regex = /\A#{pattern.split('*', -1).map { |part| Regexp.escape(part) }.join('[^.]+')}\z/
-      !!(host =~ regex)
-    end
+        regex = /\A#{pattern.split('*', -1).map { |part| Regexp.escape(part) }.join('[^.]+')}\z/
+        !!(host =~ regex)
+      end
 
-    def safe_parse(url)
-      URI.parse(url)
-    rescue URI::InvalidURIError
-      nil
-    end
+      def safe_parse(url)
+        URI.parse(url)
+      rescue URI::InvalidURIError
+        nil
+      end
 
-    def build_url_for_request(http, req)
-      return req.path if %r{\Ahttps?://}.match?(req.path)
+      def build_url_for_request(http, req)
+        return req.path if %r{\Ahttps?://}.match?(req.path)
 
-      scheme = http.use_ssl? ? "https" : "http"
-      host = http.address
-      port = http.port
-      default = http.use_ssl? ? 443 : 80
+        scheme = http.use_ssl? ? "https" : "http"
+        host = http.address
+        port = http.port
+        default = http.use_ssl? ? 443 : 80
 
-      url = "#{scheme}://#{host}"
-      url << ":#{port}" if port != default
-      url << req.path
-      url
+        url = "#{scheme}://#{host}"
+        url << ":#{port}" if port != default
+        url << req.path
+        url
+      end
     end
   end
 end