opentrace 0.15.1 → 0.17.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e5c67d0aecd2be7ec0624bd339bda99a46d8c2de8d0a04009d6778f94cefee3d
-  data.tar.gz: 0b54c97978becc24a2339e1f615de4f715388fc9247dc88099880dc7e1532a43
+  metadata.gz: '0785fe05f95bd64567435b2bb20ed18d4882a14ac765351a741cf322dc8d6ade'
+  data.tar.gz: b656ded61cf12de7b5657d69234d11fe52ffb7b9eb9aee2cc6568b33baeaa16a
 SHA512:
-  metadata.gz: 60bc99ef6e4e950851358a9dbf3b2b8342209f81ff24d58eb248c07362657d4c040c1f60e6e8fdb3cb56d625cac4f8b9a4641e953241a1af52195f27232790f6
-  data.tar.gz: d655b2237f513c8b3fe8a12e936086937fc80b1f50d5bb3766b6e5ef3ed1a137d90bf9798546aa99413633dba9e9588c87f2b99d4e54e226c0842fea720f309e
+  metadata.gz: ce7a3567bb634e3859218b7be7b57ede064ebdad47943855fc4758c764eea74a13608e2c5983e965e793f0f36786043146c00dfa65c8b5bcb85ebf4e499567d4
+  data.tar.gz: 9c01f33f3b5416e9fea909b2c3ac841742fdb6ed4b85feb156e8166585790a76d373e2e2714ea67afc9bb5d8ec2d24f040b4c53e6c7646389d55b3165f759427

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

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module OpenTrace
+  # Rails 7.0+ Error Reporter subscriber.
+  #
+  # Captures ALL exceptions reported via Rails.error (including those
+  # rescued by rescue_from in controllers). This fills the gap where
+  # process_action.action_controller only includes exception data for
+  # unhandled exceptions — rescued exceptions show status 500 but no
+  # exception_class, backtrace, or error_fingerprint.
+  #
+  # Registered automatically in the Railtie when Rails.error is available.
+  class ErrorSubscriber
+    SEVERITY_MAP = {
+      error: "ERROR",
+      warning: "WARN",
+      info: "INFO"
+    }.freeze
+
+    def report(error, handled:, severity:, context: {}, source: nil)
+      return unless OpenTrace.enabled?
+
+      # Skip if already inside an OpenTrace logging call (re-entrance guard)
+      return if Fiber[:opentrace_logging]
+
+      level = SEVERITY_MAP[severity] || "ERROR"
+
+      meta = {}
+      meta[:exception_class] = error.class.name
+      meta[:exception_message] = error.message&.slice(0, 500)
+      meta[:handled] = handled
+      meta[:error_source] = source if source
+
+      if error.backtrace
+        cleaned = clean_backtrace(error.backtrace)
+        meta[:backtrace] = cleaned.first(15)
+      end
+
+      # Capture exception cause chain
+      if error.cause
+        meta[:exception_causes] = OpenTrace.send(:build_cause_chain, error.cause, depth: 0)
+      end
+
+      # Include request params from context if available
+      if context[:params].is_a?(Hash)
+        params = context[:params].except("controller", "action")
+        meta[:params] = truncate_hash(params, 2048) unless params.empty?
+      end
+
+      # Include controller/action context
+      meta[:controller] = context[:controller] if context[:controller]
+      meta[:action] = context[:action] if context[:action]
+
+      # Merge any additional context from the reporter
+      context.each do |k, v|
+        next if %i[params controller action].include?(k)
+        meta[k] = v
+      end
+
+      OpenTrace.log(level, "#{error.class}: #{error.message&.slice(0, 200)}", meta)
+    rescue StandardError
+      # Never raise to the host app
+    end
+
+    private
+
+    def clean_backtrace(backtrace)
+      if defined?(::Rails) && ::Rails.respond_to?(:backtrace_cleaner)
+        ::Rails.backtrace_cleaner.clean(backtrace)
+      else
+        backtrace.reject { |line| line.include?("/gems/") }
+      end
+    end
+
+    def truncate_hash(hash, max_bytes)
+      json = JSON.generate(hash)
+      return hash if json.bytesize <= max_bytes
+      { _truncated: true, _size: json.bytesize }
+    rescue StandardError
+      { _truncated: true }
+    end
+  end
+end

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?
@@ -26,6 +58,18 @@ module OpenTrace
       safe_path = req.path.to_s.split("?").first
       url = "#{scheme}://#{host}#{port_str}#{safe_path}"
 
+      # Capture request body (if present and under size limit)
+      req_body = nil
+      if req.body && req.body.is_a?(String) && req.body.bytesize < MAX_BODY_CAPTURE_BYTES
+        req_body = req.body
+      end
+
+      # Capture response body (if under size limit)
+      resp_body = nil
+      if response.body && response.body.is_a?(String) && response.body.bytesize < MAX_BODY_CAPTURE_BYTES
+        resp_body = response.body
+      end
+
       if collector
         collector.record_http(
           method: req.method,
@@ -36,6 +80,27 @@ module OpenTrace
         )
       end
 
+      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,  # skip headers for now to save memory
+          request_body: req_body,
+          response_headers: nil,
+          response_body: resp_body,
+          response_size: response.body&.bytesize,
+          retry_attempt: 0,
+          error_class: nil
+        )
+        buffer.record_timeline(type: :http, name: "#{req.method} #{host}", duration_ms: duration_ms)
+      end
+
       response
     rescue IOError, SystemCallError, OpenSSL::SSL::SSLError, Timeout::Error, Net::ProtocolError => e
       # Record the failed HTTP call, then re-raise
@@ -52,6 +117,23 @@ module OpenTrace
         )
       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: e.class.name
+        )
+      end
+
       raise # ALWAYS re-raise — never swallow app errors
     end