opentrace 0.16.0 → 0.17.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e9eff1e2688a1239f8ebafd7cd59487b4ffab4619107c7fda9db580f9de04bed
-  data.tar.gz: 6a4151670c6f6b803e7fff47fe2e7621ab17c52a7576d2d43c0fd416e337ccc6
+  metadata.gz: a52fdd745f23752d86ae494048fb8b6395374ec08f7ba6b9e3edccd0bea80036
+  data.tar.gz: b9b3aaab811c9997681a535a1b50d7c9ad0e567c872cb0075c509abd7567f339
 SHA512:
-  metadata.gz: 1931c39a5b24f9aea0eeb81aacb77945a4c0f2386f13c3862172119e59c90eb13fab43e7af42981c6c8626f660a6a548bd040d6f1d087262716045e971d81ae0
-  data.tar.gz: ef27898fabf3fe17bc1aaf98cd4003b4008740685124398c5eeb80ddb47c737284ee36e99c516103d9306d00f2c18ea016d2346b93380452dfa56b15f6c6b01c
+  metadata.gz: 7dc954766e198906d4c16448b49be2e0dc26aca08e5f8fa3031d3a6f6c6d9c98f6278e2febbc3f717680522b06807c756a80f3b84dbf69c1c8c20e8ca1c99b6b
+  data.tar.gz: 0f0a49079c6bef6317208325361dfa4edd07cc509043a7e10dbceadd67ecda35311e306c2e5fb64115bf4e6fab111e23fac05ccbe5bcddb5324aad7325d4a06c

data/README.md

@@ -118,7 +118,8 @@ OpenTrace.configure do |c|
   c.service     = "billing-api"
 
   # Optional
-  c.environment = "production"           # default: nil
+  c.environment = "production"           # default: auto-detected from
+                                         # OPENTRACE_ENV → Rails.env → RACK_ENV → RAILS_ENV
   c.timeout     = 1.0                    # HTTP timeout in seconds (default: 1.0)
   c.enabled     = true                   # default: true
   c.min_level   = :info                  # minimum level to forward (default: :info)
@@ -405,10 +406,11 @@ In a Rails app, add an initializer:
 ```ruby
 # config/initializers/opentrace.rb
 OpenTrace.configure do |c|
-  c.endpoint    = ENV["OPENTRACE_ENDPOINT"]
-  c.api_key     = ENV["OPENTRACE_API_KEY"]
-  c.service     = "my-rails-app"
-  c.environment = Rails.env
+  c.endpoint = ENV["OPENTRACE_ENDPOINT"]
+  c.api_key  = ENV["OPENTRACE_API_KEY"]
+  c.service  = "my-rails-app"
+  # c.environment is auto-resolved from OPENTRACE_ENV (preferred) or
+  # Rails.env, so you only need to set it explicitly for unusual cases.
 end
 ```
 

data/lib/opentrace/audit_tracker.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+module OpenTrace
+  # Auto-included concern on ActiveRecord::Base when audit_tracking is enabled.
+  # Captures before/after diffs on create, update, and destroy using saved_changes.
+  module AuditTracker
+    def self.included(base)
+      base.after_create  { |record| OpenTrace::AuditTracker.track(record, :create) }
+      base.after_update  { |record| OpenTrace::AuditTracker.track(record, :update) }
+      base.after_destroy { |record| OpenTrace::AuditTracker.track(record, :destroy) }
+    end
+
+    class << self
+      def track(record, action)
+        buffer = Fiber[:opentrace_buffer]
+        return unless buffer
+        return unless OpenTrace.config.audit_tracking
+
+        model_name = record.class.name
+        return if excluded_model?(model_name)
+
+        # Resolve actor
+        actor_id = nil
+        actor_type = nil
+        actor_proc = OpenTrace.config.audit_actor
+        if actor_proc.is_a?(Proc)
+          actor = actor_proc.call rescue nil
+          if actor
+            actor_id = actor.respond_to?(:id) ? actor.id.to_s : actor.to_s
+            actor_type = actor.class.name
+          end
+        end
+
+        case action
+        when :create
+          after_values = filter_fields(record.attributes)
+          buffer.record_audit(
+            action: "create",
+            record_type: model_name,
+            record_id: record.id.to_s,
+            actor_id: actor_id,
+            actor_type: actor_type,
+            changed_fields: nil,
+            full_before: nil,
+            full_after: after_values
+          )
+
+        when :update
+          changes = record.saved_changes
+          return if changes.empty?
+
+          filtered = filter_changes(changes)
+          return if filtered.empty?
+
+          changed_fields = {}
+          filtered.each do |field, (old_val, new_val)|
+            changed_fields[field] = { "from" => old_val, "to" => new_val }
+          end
+
+          buffer.record_audit(
+            action: "update",
+            record_type: model_name,
+            record_id: record.id.to_s,
+            actor_id: actor_id,
+            actor_type: actor_type,
+            changed_fields: changed_fields,
+            full_before: nil,
+            full_after: nil
+          )
+
+        when :destroy
+          before_values = filter_fields(record.attributes)
+          buffer.record_audit(
+            action: "destroy",
+            record_type: model_name,
+            record_id: record.id.to_s,
+            actor_id: actor_id,
+            actor_type: actor_type,
+            changed_fields: nil,
+            full_before: before_values,
+            full_after: nil
+          )
+        end
+
+        buffer.record_timeline(type: :audit, name: "#{model_name}##{action}")
+      rescue StandardError
+        # Never affect the host app
+      end
+
+      private
+
+      def excluded_model?(model_name)
+        OpenTrace.config.audit_exclude_models.any? { |m| model_name == m }
+      rescue StandardError
+        false
+      end
+
+      def filter_changes(changes)
+        exclude = OpenTrace.config.audit_exclude_fields
+        changes.reject { |field, _| exclude.include?(field.to_s) }
+      rescue StandardError
+        changes
+      end
+
+      def filter_fields(attributes)
+        exclude = OpenTrace.config.audit_exclude_fields
+        attributes.reject { |field, _| exclude.include?(field.to_s) }
+      rescue StandardError
+        attributes
+      end
+    end
+  end
+end

data/lib/opentrace/buffer_pool.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require_relative "request_buffer"
+
+module OpenTrace
+  class BufferPool
+    def initialize(size: 32, max_buffer_bytes: 1_048_576, max_audit_events: 50)
+      @max_buffer_bytes = max_buffer_bytes
+      @max_audit_events = max_audit_events
+      @max_size = size
+
+      @mutex = Mutex.new
+      @pool  = Array.new(size) { RequestBuffer.new(max_buffer_bytes: max_buffer_bytes, max_audit_events: max_audit_events) }
+      @checked_out = 0
+    end
+
+    # Returns a RequestBuffer ready for use. Pulls from pool if available,
+    # allocates a new one if pool is empty. Sets id and started_at.
+    def checkout
+      buffer = @mutex.synchronize do
+        buf = @pool.pop
+        @checked_out += 1
+        buf
+      end
+
+      # Pool was empty — allocate fresh (outside the lock)
+      buffer ||= RequestBuffer.new(max_buffer_bytes: @max_buffer_bytes, max_audit_events: @max_audit_events)
+
+      buffer.id = ULID.generate
+      buffer.started_at = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+
+      buffer
+    end
+
+    # Resets the buffer and returns it to the pool. If the pool is already
+    # at max capacity, the buffer is discarded (GC will collect it).
+    def checkin(buffer)
+      buffer.reset!
+
+      @mutex.synchronize do
+        @checked_out -= 1
+        @checked_out = 0 if @checked_out < 0 # safety clamp
+
+        if @pool.size < @max_size
+          @pool.push(buffer)
+        end
+        # else: discard — pool is full
+      end
+    end
+
+    # Returns a snapshot of pool statistics.
+    def stats
+      @mutex.synchronize do
+        {
+          pool_size: @max_size,
+          available: @pool.size,
+          checked_out: @checked_out
+        }
+      end
+    end
+  end
+end

data/lib/opentrace/capture_rules.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+module OpenTrace
+  class CaptureRules
+    LEVELS = %i[none minimal standard full].freeze
+    LEVEL_ORDER = LEVELS.each_with_index.to_h.freeze # { none: 0, minimal: 1, standard: 2, full: 3 }
+
+    def initialize(&block)
+      @path_rules = []
+      @error_rule = nil
+      @slow_rule = nil
+
+      block&.call(self)
+    end
+
+    # Register a path-matching rule. Pattern supports:
+    #   ** — matches any number of path segments (including zero)
+    #   *  — matches exactly one path segment
+    def on_path(pattern, &block)
+      regex = path_pattern_to_regex(pattern)
+      @path_rules << { regex: regex, block: block }
+    end
+
+    # Register a rule that fires when the request resulted in an error.
+    def on_error(&block)
+      @error_rule = block
+    end
+
+    # Register a rule that fires when the request duration exceeds a threshold.
+    # threshold is in milliseconds.
+    def on_slow(threshold:, &block)
+      @slow_rule = { threshold: threshold, block: block }
+    end
+
+    # Evaluate all rules for a given request and return the final capture level.
+    #
+    # env          — Rack env hash (must contain "PATH_INFO")
+    # base_level   — fallback level when no path rule matches (default :standard)
+    # status       — HTTP response status (not used directly, reserved)
+    # duration_ms  — request duration in milliseconds (for on_slow)
+    # error        — whether the request raised an error (for on_error)
+    def resolve(env, base_level: :standard, status: nil, duration_ms: nil, error: false)
+      level = resolve_path(env) || base_level
+
+      # Post-request upgrades: only go up, never down
+      if error && @error_rule
+        error_level = @error_rule.call
+        level = max_level(level, error_level)
+      end
+
+      if duration_ms && @slow_rule && duration_ms > @slow_rule[:threshold]
+        slow_level = @slow_rule[:block].call
+        level = max_level(level, slow_level)
+      end
+
+      level
+    end
+
+    # Apply per-domain overrides. If the domain has an explicit override, use it.
+    # Otherwise return the resolved_level as-is.
+    def resolve_domain(domain, resolved_level, overrides)
+      override = overrides[domain]
+      override.nil? ? resolved_level : override
+    end
+
+    private
+
+    # Find the first path rule that matches and return its level.
+    # Returns nil if no rule matches.
+    def resolve_path(env)
+      path = env["PATH_INFO"].to_s
+
+      @path_rules.each do |rule|
+        return rule[:block].call if rule[:regex].match?(path)
+      end
+
+      nil
+    end
+
+    # Return whichever level is higher in the ordering.
+    def max_level(a, b)
+      (LEVEL_ORDER[a] || 0) >= (LEVEL_ORDER[b] || 0) ? a : b
+    end
+
+    # Convert a path pattern to a regex.
+    #   ** → matches any characters (including /)
+    #   *  → matches any characters except /
+    #
+    # Processing order matters: replace ** first (as a distinct token),
+    # then replace remaining single *.
+    def path_pattern_to_regex(pattern)
+      # Escape everything except our wildcards
+      # Step 1: Replace ** with a unique placeholder
+      escaped = pattern.gsub("**", "\x00DOUBLE\x00")
+      # Step 2: Replace remaining single * with a placeholder
+      escaped = escaped.gsub("*", "\x00SINGLE\x00")
+      # Step 3: Escape regex metacharacters in the rest
+      escaped = Regexp.escape(escaped)
+      # Step 4: Restore placeholders with regex patterns
+      escaped = escaped.gsub("\x00DOUBLE\x00", ".*")
+      escaped = escaped.gsub("\x00SINGLE\x00", "[^/]+")
+
+      Regexp.new("\\A#{escaped}\\z")
+    end
+  end
+end

data/lib/opentrace/client.rb

@@ -12,7 +12,7 @@ module OpenTrace
     MAX_QUEUE_SIZE = 1000
     PAYLOAD_MAX_BYTES = 262_144 # 256 KB (default; use config.max_payload_bytes to override)
     MAX_RATE_LIMIT_BACKOFF = 60 # Cap Retry-After at 60 seconds
-    API_VERSION = 1
+    API_VERSION = 2
 
     attr_reader :stats
 
@@ -249,9 +249,9 @@ module OpenTrace
           end
         end
         # PII scrubbing (runs on background thread)
-        if @config.pii_scrubbing && payload[:metadata]
+        if @config.pii_scrubbing && payload[:body]
           active_patterns = build_pii_patterns
-          PiiScrubber.scrub!(payload[:metadata], patterns: active_patterns)
+          PiiScrubber.scrub!(payload[:body], patterns: active_patterns)
         end
 
         fit_payload(payload)
@@ -583,24 +583,31 @@ module OpenTrace
     end
 
     def truncate_payload(payload)
-      meta = payload[:metadata]&.dup || {}
+      body = payload[:body]&.dup || {}
 
       # Truncation priority: remove largest optional fields first
-      meta.delete(:backtrace)
-      meta.delete(:params)
-      meta.delete(:job_arguments)
-      meta[:sql] = meta[:sql][0, 200] + "..." if meta[:sql].is_a?(String) && meta[:sql].length > 200
-      meta[:exception_message] = meta[:exception_message][0, 200] + "..." if meta[:exception_message].is_a?(String) && meta[:exception_message].length > 200
-
-      result = payload.merge(metadata: meta)
-
-      # Remove timeline from request_summary (can be very large)
-      if result[:request_summary]
-        result[:request_summary] = result[:request_summary].dup
-        result[:request_summary].delete(:timeline)
+      body.delete(:timeline)
+      body.delete(:queries)
+
+      if body[:exception].is_a?(Hash)
+        exc = body[:exception] = body[:exception].dup
+        exc.delete(:backtrace)
+        exc[:message] = exc[:message][0, 200] + "..." if exc[:message].is_a?(String) && exc[:message].length > 200
       end
 
-      result
+      if body[:context].is_a?(Hash)
+        ctx = body[:context] = body[:context].dup
+        ctx.delete(:params)
+        ctx.delete(:job_arguments)
+        ctx[:sql] = ctx[:sql][0, 200] + "..." if ctx[:sql].is_a?(String) && ctx[:sql].length > 200
+      end
+
+      if body[:request].is_a?(Hash)
+        body[:request] = body[:request].dup
+        body[:request].delete(:params)
+      end
+
+      payload.merge(body: body)
     end
   end
 end

data/lib/opentrace/config.rb

@@ -29,10 +29,24 @@ module OpenTrace
                   :pii_scrubbing, :pii_patterns, :pii_disabled_patterns,
                   :session_tracking,
                   :on_error, :after_send,
-                :transport, :socket_path,
-                :local_vars_capture,
-                :explain_slow_queries, :explain_threshold_ms,
-                :runtime_metrics, :runtime_metrics_interval
+                  :transport, :socket_path,
+                  :local_vars_capture,
+                  :explain_slow_queries, :explain_threshold_ms,
+                  :runtime_metrics, :runtime_metrics_interval,
+                  # Deep capture
+                  :capture_depth, :capture_rules_block,
+                  # Per-domain overrides (nil = follow capture_depth)
+                  :email_capture, :sql_capture, :http_capture,
+                  :audit_capture, :request_capture,
+                  # Buffering & safety
+                  :max_buffer_bytes, :max_total_buffer_bytes, :max_queue_bytes,
+                  # Audit trail
+                  :audit_tracking, :audit_max_events_per_request,
+                  :audit_exclude_models, :audit_exclude_fields, :audit_actor,
+                  # Body capture
+                  :max_request_body_bytes,
+                  # Serialization format
+                  :serialization_format
 
     # Custom writers that invalidate caches
     attr_reader :enabled, :min_level, :allowed_levels, :ignore_paths, :sample_rate
@@ -127,6 +141,29 @@ module OpenTrace
       @explain_threshold_ms = 100.0   # Threshold for EXPLAIN capture
       @runtime_metrics = false        # Collect GC/runtime metrics
       @runtime_metrics_interval = 30  # Interval in seconds
+      # Deep capture
+      @capture_depth = :standard
+      @capture_rules_block = nil
+      # Per-domain overrides (nil = follow capture_depth)
+      @email_capture = nil
+      @sql_capture = nil
+      @http_capture = nil
+      @audit_capture = nil
+      @request_capture = nil
+      # Buffering & safety
+      @max_buffer_bytes = 1_048_576        # 1MB per request
+      @max_total_buffer_bytes = 52_428_800 # 50MB global
+      @max_queue_bytes = 10_485_760        # 10MB
+      # Audit trail
+      @audit_tracking = false
+      @audit_max_events_per_request = 50
+      @audit_exclude_models = []
+      @audit_exclude_fields = %w[updated_at created_at password_digest]
+      @audit_actor = nil
+      # Body capture
+      @max_request_body_bytes = 262_144    # 256KB
+      # Serialization format
+      @serialization_format = :json
       @level_cache = nil
       @enabled_cache = nil
     end
@@ -172,9 +209,39 @@ module OpenTrace
     # and lazily when settings change afterward.
     def finalize!
       @enabled_cache = nil
+      resolve_environment!
       build_level_cache!
     end
 
+    # Resolve environment from env vars if the caller didn't set it explicitly.
+    # Fallback order:
+    #   1. explicit config (c.environment = "...")
+    #   2. ENV["OPENTRACE_ENV"]            — canonical opentrace variable
+    #   3. Rails.env                        — Rails apps, no extra config needed
+    #   4. ENV["RACK_ENV"]                  — Rack apps without Rails
+    #   5. ENV["RAILS_ENV"]                 — edge case: RAILS_ENV set but Rails not loaded
+    # The first non-empty value wins. Callers who want "no env" can explicitly
+    # clear it after finalize!, but there's rarely a reason to.
+    def resolve_environment!
+      return if @environment && !@environment.to_s.empty?
+
+      if (v = ENV["OPENTRACE_ENV"]) && !v.empty?
+        @environment = v
+        return
+      end
+      if defined?(Rails) && Rails.respond_to?(:env) && (v = Rails.env.to_s) && !v.empty?
+        @environment = v
+        return
+      end
+      if (v = ENV["RACK_ENV"]) && !v.empty?
+        @environment = v
+        return
+      end
+      if (v = ENV["RAILS_ENV"]) && !v.empty?
+        @environment = v
+      end
+    end
+
     # Maps OpenTrace min_level to Ruby Logger severity constant.
     # Used by LogForwarder to set its level so BroadcastLogger
     # doesn't downgrade the effective log level for the entire app.
@@ -190,6 +257,10 @@ module OpenTrace
       LEVEL_TO_LOGGER_SEVERITY[min_level.to_s.downcase.to_sym] || 0
     end
 
+    def capture_rules(&block)
+      @capture_rules_block = block
+    end
+
     private
 
     def build_level_cache!

data/lib/opentrace/error_subscriber.rb

@@ -34,7 +34,6 @@ module OpenTrace
       if error.backtrace
         cleaned = clean_backtrace(error.backtrace)
         meta[:backtrace] = cleaned.first(15)
-        meta[:error_fingerprint] = OpenTrace.send(:compute_error_fingerprint, error.class.name, cleaned)
       end
 
       # Capture exception cause chain

data/lib/opentrace/http_tracker.rb

@@ -4,6 +4,38 @@ require "net/http"
 
 module OpenTrace
   module HttpTracker
+    # Max body size to capture (64KB) — avoids bloating memory with large payloads
+    MAX_BODY_CAPTURE_BYTES = 65_536
+
+    VENDOR_PATTERNS = {
+      "stripe" => /api\.stripe\.com/i,
+      "sendgrid" => /api\.sendgrid\.com/i,
+      "twilio" => /api\.twilio\.com/i,
+      "slack" => /slack\.com/i,
+      "github" => /api\.github\.com/i,
+      "aws" => /\.amazonaws\.com/i,
+      "google" => /googleapis\.com/i,
+      "mailgun" => /api\.mailgun\.net/i,
+      "postmark" => /api\.postmarkapp\.com/i,
+      "braintree" => /api\.braintreegateway\.com/i,
+      "paypal" => /api\.paypal\.com/i,
+      "shopify" => /\.myshopify\.com|\.shopify\.com/i,
+      "intercom" => /api\.intercom\.io/i,
+      "segment" => /api\.segment\.io/i,
+      "sentry" => /sentry\.io/i,
+      "datadog" => /api\.datadoghq\.com/i,
+      "plaid" => /\.plaid\.com/i,
+    }.freeze
+
+    def self.infer_vendor(host)
+      return nil unless host
+
+      VENDOR_PATTERNS.each do |vendor, pattern|
+        return vendor if pattern.match?(host)
+      end
+      nil
+    end
+
     def request(req, body = nil, &block)
       # Guard 1: skip if disabled
       return super unless OpenTrace.enabled?
@@ -11,14 +43,34 @@ module OpenTrace
       # Guard 2: skip if this IS an OpenTrace dispatch call (prevent infinite recursion)
       return super if Fiber[:opentrace_http_tracking_disabled]
 
-      # Inject trace context into outgoing request headers
-      inject_trace_context(req) if OpenTrace.config.trace_propagation
+      # Trace context injection is bookkeeping — must never raise to the host.
+      begin
+        inject_trace_context(req) if OpenTrace.config.trace_propagation
+      rescue StandardError
+      end
 
-      collector = Fiber[:opentrace_collector]
       start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
 
-      response = super
+      begin
+        response = super
+      rescue IOError, SystemCallError, OpenSSL::SSL::SSLError, Timeout::Error, Net::ProtocolError => e
+        # Real network error from the host's HTTP call. Record it, then re-raise
+        # so the host app sees the error it's expecting to handle.
+        record_http_failure(req, e, start_time) rescue nil
+        raise
+      end
+
+      # Bookkeeping for a successful response. Any bug here (NoMethodError on
+      # a streaming body, a payload builder regression, etc.) must NOT bubble
+      # into host code — swallow and move on.
+      record_http_success(req, response, start_time) rescue nil
+
+      response
+    end
+
+    private
 
+    def record_http_success(req, response, start_time)
       duration_ms = (Process.clock_gettime(Process::CLOCK_MONOTONIC) - start_time) * 1000
       host = address
       port_str = (port == 443 || port == 80) ? "" : ":#{port}"
@@ -26,6 +78,11 @@ module OpenTrace
       safe_path = req.path.to_s.split("?").first
       url = "#{scheme}://#{host}#{port_str}#{safe_path}"
 
+      req_body = capturable_body(req.body)
+      resp_body = capturable_body(response.body)
+      resp_size = body_size(response)
+
+      collector = Fiber[:opentrace_collector]
       if collector
         collector.record_http(
           method: req.method,
@@ -36,11 +93,33 @@ module OpenTrace
         )
       end
 
-      response
-    rescue IOError, SystemCallError, OpenSSL::SSL::SSLError, Timeout::Error, Net::ProtocolError => e
-      # Record the failed HTTP call, then re-raise
+      buffer = Fiber[:opentrace_buffer]
+      if buffer
+        vendor = OpenTrace::HttpTracker.infer_vendor(host)
+        buffer.record_http(
+          method: req.method,
+          url: url,
+          host: host,
+          vendor: vendor,
+          status: response.code.to_i,
+          duration_ms: duration_ms,
+          request_headers: nil,
+          request_body: req_body,
+          response_headers: nil,
+          response_body: resp_body,
+          response_size: resp_size,
+          retry_attempt: 0,
+          error_class: nil
+        )
+        buffer.record_timeline(type: :http, name: "#{req.method} #{host}", duration_ms: duration_ms)
+      end
+    end
+
+    def record_http_failure(req, error, start_time)
       duration_ms = start_time ? (Process.clock_gettime(Process::CLOCK_MONOTONIC) - start_time) * 1000 : 0
+      req_body = req ? capturable_body(req.body) : nil
 
+      collector = Fiber[:opentrace_collector]
       if collector
         collector.record_http(
           method: req&.method,
@@ -48,14 +127,42 @@ module OpenTrace
           host: address,
           status: 0,
           duration_ms: duration_ms,
-          error: e.class.name
+          error: error.class.name
+        )
+      end
+
+      buffer = Fiber[:opentrace_buffer]
+      if buffer
+        vendor = OpenTrace::HttpTracker.infer_vendor(address)
+        buffer.record_http(
+          method: req&.method,
+          url: "#{address}#{req&.path}",
+          host: address,
+          vendor: vendor,
+          status: 0,
+          duration_ms: duration_ms,
+          request_body: req_body,
+          response_body: nil,
+          response_size: nil,
+          error_class: error.class.name
         )
       end
+    end
 
-      raise # ALWAYS re-raise — never swallow app errors
+    def capturable_body(body)
+      return nil unless body.is_a?(String)
+      return nil if body.bytesize >= MAX_BODY_CAPTURE_BYTES
+      body
     end
 
-    private
+    # Response body size when it can be determined without re-reading the stream.
+    # Streaming responses (Net::ReadAdapter) can't be re-read, so we fall back
+    # to Content-Length when present, otherwise nil.
+    def body_size(response)
+      return response.body.bytesize if response.body.is_a?(String)
+      len = response["Content-Length"]
+      len ? len.to_i : nil
+    end
 
     def inject_trace_context(req)
       trace_id = Fiber[:opentrace_trace_id]