opentrace 0.17.0 → 0.17.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '0785fe05f95bd64567435b2bb20ed18d4882a14ac765351a741cf322dc8d6ade'
-  data.tar.gz: b656ded61cf12de7b5657d69234d11fe52ffb7b9eb9aee2cc6568b33baeaa16a
+  metadata.gz: f2ea4cd5b52e24bbbed81f9d9c9f522f8001bf379407cd01c126b659d0a4efe5
+  data.tar.gz: 52cb261f68c4e1280b1c164fb732e9a02123abd70a0274e70ed8894af76b9c9b
 SHA512:
-  metadata.gz: ce7a3567bb634e3859218b7be7b57ede064ebdad47943855fc4758c764eea74a13608e2c5983e965e793f0f36786043146c00dfa65c8b5bcb85ebf4e499567d4
-  data.tar.gz: 9c01f33f3b5416e9fea909b2c3ac841742fdb6ed4b85feb156e8166585790a76d373e2e2714ea67afc9bb5d8ec2d24f040b4c53e6c7646389d55b3165f759427
+  metadata.gz: 1b5cbf4a21b4e09f9246cfa89e8d45f21f6b7b6ad4d232a2b909a8b76fd9ce6829cee208b8bfec596198954de50574a52d249dc63761c8be3e394640f3885b9d
+  data.tar.gz: d7714397187d069769743c30d39a3ccf865624c40ba86d6f3c9a0fad5bb56f10417660045eb4c07123dd0260359b104f39fd2449beb7371f32512836cd585257

data/lib/opentrace/client.rb

@@ -6,6 +6,7 @@ require "json"
 require "zlib"
 require "stringio"
 require "securerandom"
+require_relative "serializer"
 
 module OpenTrace
   class Client
@@ -20,6 +21,8 @@ module OpenTrace
       @config = config
       @sampler = sampler
       @queue  = Thread::Queue.new
+      @queue_bytes = 0
+      @queue_bytes_mutex = Mutex.new
       @mutex  = Mutex.new
       @thread = nil
       @pid    = Process.pid
@@ -46,14 +49,13 @@ module OpenTrace
 
       reset_after_fork! if forked?
 
-      # Drop newest if queue is full
-      if @queue.size >= MAX_QUEUE_SIZE
+      byte_size = estimate_payload_bytes(payload)
+      unless push_queue_item(payload, byte_size: byte_size)
         @stats.increment(:dropped_queue_full)
         fire_on_drop(1, :queue_full)
         return
       end
 
-      @queue.push(payload)
       @stats.increment(:enqueued)
       ensure_thread_running
     end
@@ -62,6 +64,10 @@ module OpenTrace
       @queue.size
     end
 
+    def queue_byte_size
+      @queue_bytes_mutex.synchronize { @queue_bytes }
+    end
+
     def circuit_state
       @circuit_breaker.state
     end
@@ -73,6 +79,7 @@ module OpenTrace
     def stats_snapshot
       @stats.to_h.merge(
         queue_size: queue_size,
+        queue_byte_size: queue_byte_size,
         circuit_state: circuit_state,
         auth_suspended: @auth_suspended,
         server_capabilities: @server_capabilities
@@ -99,6 +106,8 @@ module OpenTrace
       # Re-create everything cleanly in the child process.
       @pid    = Process.pid
       @queue  = Thread::Queue.new
+      @queue_bytes = 0
+      @queue_bytes_mutex = Mutex.new
       @mutex  = Mutex.new
       @thread = nil
       @http   = nil # Parent's connection is unusable after fork
@@ -178,8 +187,8 @@ module OpenTrace
         # Non-blocking drain: grab everything currently in the queue
         while batch.size < @config.batch_size
           begin
-            item = @queue.pop(true) # non_block = true
-            batch << item
+            item = unwrap_queue_item(@queue.pop(true)) # non_block = true
+            batch << item if item
           rescue ThreadError, ClosedQueueError
             break # queue empty or closed
           end
@@ -216,9 +225,9 @@ module OpenTrace
       if timeout <= 0
         # Deadline already passed — still try a non-blocking pop in case
         # items arrived while we were busy (e.g. during version check).
-        @queue.pop(true)
+        unwrap_queue_item(@queue.pop(true))
       else
-        @queue.pop(timeout: [timeout, MAX_POP_WAIT].min)
+        unwrap_queue_item(@queue.pop(timeout: [timeout, MAX_POP_WAIT].min))
       end
     rescue ThreadError, ClosedQueueError
       nil
@@ -324,9 +333,8 @@ module OpenTrace
       # Re-enqueue batch items if space allows
       re_enqueued = 0
       batch.each do |payload|
-        break if @queue.size >= MAX_QUEUE_SIZE
         begin
-          @queue.push(payload)
+          break unless push_queue_item(payload)
           re_enqueued += 1
         rescue ClosedQueueError
           break
@@ -504,6 +512,50 @@ module OpenTrace
       PiiScrubber::PATTERNS.values
     end
 
+    def push_queue_item(payload, byte_size: nil)
+      byte_size ||= estimate_payload_bytes(payload)
+
+      @queue_bytes_mutex.synchronize do
+        return false if @queue.closed?
+        return false if @queue.size >= MAX_QUEUE_SIZE
+        return false if @config.max_queue_bytes && @queue_bytes + byte_size > @config.max_queue_bytes
+
+        @queue.push([payload, byte_size])
+        @queue_bytes += byte_size
+        true
+      end
+    rescue ClosedQueueError
+      false
+    end
+
+    def unwrap_queue_item(item)
+      return nil unless item
+
+      if item.is_a?(Array) && item.length == 2 && item[1].is_a?(Integer)
+        payload, byte_size = item
+        decrement_queue_bytes(byte_size)
+        payload
+      else
+        item
+      end
+    end
+
+    def decrement_queue_bytes(byte_size)
+      @queue_bytes_mutex.synchronize do
+        @queue_bytes = [0, @queue_bytes - byte_size.to_i].max
+      end
+    end
+
+    def estimate_payload_bytes(payload)
+      if defined?(Serializer)
+        Serializer.estimate_size(payload)
+      else
+        JSON.generate(payload).bytesize
+      end
+    rescue StandardError
+      1024
+    end
+
     def fire_on_drop(count, reason)
       @config.on_drop&.call(count, reason)
     rescue StandardError

data/lib/opentrace/http_tracker.rb

@@ -43,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}"
@@ -58,18 +78,11 @@ 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
+      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,
@@ -90,22 +103,23 @@ module OpenTrace
           vendor: vendor,
           status: response.code.to_i,
           duration_ms: duration_ms,
-          request_headers: nil,  # skip headers for now to save memory
+          request_headers: nil,
           request_body: req_body,
           response_headers: nil,
           response_body: resp_body,
-          response_size: response.body&.bytesize,
+          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
 
-      response
-    rescue IOError, SystemCallError, OpenSSL::SSL::SSLError, Timeout::Error, Net::ProtocolError => e
-      # Record the failed HTTP call, then re-raise
+    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,
@@ -113,7 +127,7 @@ module OpenTrace
           host: address,
           status: 0,
           duration_ms: duration_ms,
-          error: e.class.name
+          error: error.class.name
         )
       end
 
@@ -130,14 +144,25 @@ module OpenTrace
           request_body: req_body,
           response_body: nil,
           response_size: nil,
-          error_class: e.class.name
+          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]

data/lib/opentrace/instrumentation_context.rb

@@ -3,6 +3,7 @@
 require_relative "buffer_pool"
 require_relative "memory_guard"
 require_relative "capture_rules"
+require_relative "config"
 
 module OpenTrace
   class InstrumentationContext
@@ -20,6 +21,12 @@ module OpenTrace
       # Returns the buffer (for callers that need it).
       def setup(env: nil, job: nil)
         buf = buffer_pool.checkout
+        allocation_bytes = buf.byte_size
+
+        unless memory_guard.allocate(allocation_bytes)
+          buffer_pool.checkin(buf)
+          return nil
+        end
 
         buf.event_type = if env
                            :http_request
@@ -27,6 +34,7 @@ module OpenTrace
                            :job_perform
                          end
 
+        Fiber[:opentrace_buffer_allocation_bytes] = allocation_bytes
         Fiber[FIBER_KEY] = buf
         buf
       end
@@ -38,34 +46,40 @@ module OpenTrace
       # document, checks the buffer back into the pool, and clears the Fiber
       # local.
       #
-      # Returns the document Hash. The caller is responsible for enqueueing.
+      # Returns the document Hash, or nil when capture resolves to :none.
+      # The caller is responsible for enqueueing.
       def teardown(status: nil, duration_ms: nil, error: false)
         buf = Fiber[FIBER_KEY]
         return nil unless buf
 
-        # Resolve capture level
-        capture_level = resolve_capture_level(
-          buf, status: status, duration_ms: duration_ms, error: error
-        )
-
-        # Apply memory guard — may downgrade under pressure
-        capture_level = memory_guard.effective_level(capture_level)
-
-        # Normalize: MemoryGuard returns :none when exceeded, but RequestBuffer
-        # only understands :minimal / :standard / :full. Map :none to :minimal.
-        capture_level = :minimal if capture_level == :none
-
-        # Build domain overrides from capture rules (if configured)
-        domain_overrides = {}
-
-        # Produce the document
-        doc = buf.to_document(capture_level: capture_level, domain_overrides: domain_overrides)
-
-        # Return buffer to pool and clear Fiber local
-        buffer_pool.checkin(buf)
-        Fiber[FIBER_KEY] = nil
-
-        doc
+        begin
+          # Resolve capture level
+          capture_level = resolve_capture_level(
+            buf, status: status, duration_ms: duration_ms, error: error
+          )
+
+          # Apply memory guard — may downgrade under pressure
+          capture_level = memory_guard.effective_level(capture_level)
+          return nil if capture_level == :none
+
+          # Build domain overrides from capture rules (if configured)
+          domain_overrides = configured_domain_overrides
+
+          # Produce the document
+          doc = buf.to_document(capture_level: capture_level, domain_overrides: domain_overrides)
+          doc[:duration_ms] = duration_ms if duration_ms
+          doc[:pending_explains] = Fiber[:opentrace_pending_explains] if Fiber[:opentrace_pending_explains]
+
+          doc
+        ensure
+          allocation_bytes = Fiber[:opentrace_buffer_allocation_bytes].to_i
+          memory_guard.release(allocation_bytes) if allocation_bytes.positive?
+
+          # Return buffer to pool and clear Fiber local
+          buffer_pool.checkin(buf)
+          Fiber[FIBER_KEY] = nil
+          Fiber[:opentrace_buffer_allocation_bytes] = nil
+        end
       end
 
       # ── Convenience accessors ──
@@ -83,15 +97,28 @@ module OpenTrace
       # ── Singleton resources (lazy-initialized) ──
 
       def buffer_pool
-        @buffer_pool ||= BufferPool.new
+        cfg = active_config
+        @buffer_pool ||= BufferPool.new(
+          max_buffer_bytes: cfg.max_buffer_bytes,
+          max_audit_events: cfg.audit_max_events_per_request
+        )
       end
 
       def memory_guard
-        @memory_guard ||= MemoryGuard.new
+        cfg = active_config
+        @memory_guard ||= MemoryGuard.new(max_total_bytes: cfg.max_total_buffer_bytes)
+      end
+
+      def configure!(config)
+        @config = config
+        @buffer_pool = nil
+        @memory_guard = nil
+        @capture_rules = config.capture_rules_block ? CaptureRules.new(&config.capture_rules_block) : nil
       end
 
       # Reset singletons (for testing).
       def reset!
+        @config = nil
         @buffer_pool = nil
         @memory_guard = nil
         @capture_rules = nil
@@ -106,9 +133,10 @@ module OpenTrace
       # If CaptureRules are configured, use them; otherwise default to :standard.
       def resolve_capture_level(buf, status:, duration_ms:, error:)
         rules = capture_rules
+        base_level = configured_capture_depth
 
         unless rules
-          return :standard
+          return base_level
         end
 
         # CaptureRules.resolve expects a Rack env for path matching.
@@ -122,12 +150,36 @@ module OpenTrace
 
         rules.resolve(
           env,
-          base_level: :standard,
+          base_level: base_level,
           status: status,
           duration_ms: duration_ms,
           error: error
         )
       end
+
+      def configured_capture_depth
+        level = active_config.capture_depth.to_s.downcase.to_sym
+        CaptureRules::LEVELS.include?(level) ? level : :standard
+      rescue StandardError
+        :standard
+      end
+
+      def configured_domain_overrides
+        cfg = active_config
+        {
+          email_capture: cfg.email_capture,
+          sql_capture: cfg.sql_capture,
+          http_capture: cfg.http_capture,
+          audit_capture: cfg.audit_capture,
+          request_capture: cfg.request_capture
+        }.compact
+      rescue StandardError
+        {}
+      end
+
+      def active_config
+        @config || (OpenTrace.respond_to?(:config) ? OpenTrace.config : Config.new)
+      end
     end
   end
 end

data/lib/opentrace/logger.rb

@@ -24,11 +24,32 @@ module OpenTrace
     end
 
     def add(severity, message = nil, progname = nil, &block)
-      # Delegate to wrapped logger first (synchronous, as required)
-      @wrapped_logger.add(severity, message, progname, &block)
+      if block && message.nil?
+        evaluated = false
+        resolved_message = nil
+        cached_block = proc do
+          unless evaluated
+            resolved_message = block.call
+            evaluated = true
+          end
+          resolved_message
+        end
+
+        # Delegate to wrapped logger first (synchronous, as required)
+        @wrapped_logger.add(severity, message, progname, &cached_block)
+
+        # If the wrapped logger filtered this level, Ruby Logger never
+        # evaluates the block. Match that behavior for forwarding.
+        return true unless evaluated
 
-      # Forward to OpenTrace, never raise
-      forward_to_opentrace(severity, message, progname, &block)
+        forward_to_opentrace(severity, resolved_message, nil)
+      else
+        # Delegate to wrapped logger first (synchronous, as required)
+        @wrapped_logger.add(severity, message, progname)
+
+        # Forward to OpenTrace, never raise
+        forward_to_opentrace(severity, message, progname)
+      end
 
       true
     rescue StandardError

data/lib/opentrace/middleware.rb

@@ -21,6 +21,7 @@ module OpenTrace
       opentrace_session_id
       opentrace_pending_explains
       opentrace_buffer
+      opentrace_buffer_allocation_bytes
     ].freeze
 
     def initialize(app)
@@ -30,6 +31,7 @@ module OpenTrace
     def call(env)
       # When OpenTrace is disabled, pass through with zero overhead
       return @app.call(env) unless OpenTrace.enabled?
+      return @app.call(env) if ignored_path?(env["PATH_INFO"])
 
       # Sampling: skip ALL Fiber-local setup for unsampled requests.
       # Subscribers check Fiber-locals and return instantly when nil.
@@ -76,7 +78,7 @@ module OpenTrace
       end
 
       # ── Deep capture: set up InstrumentationContext ──
-      buffer = setup_buffer(env, cfg)
+      buffer = setup_buffer(env, cfg) if request_capture_enabled?(cfg)
 
       # ── Call the downstream app ──
       start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
@@ -127,10 +129,32 @@ module OpenTrace
       FIBER_KEYS.each { |key| Fiber[key] = nil }
     end
 
+    def ignored_path?(path)
+      return false if path.nil?
+
+      OpenTrace.config.ignore_paths.any? do |entry|
+        entry.is_a?(Regexp) ? entry.match?(path) : path == entry
+      end
+    rescue StandardError
+      false
+    end
+
+    def request_capture_enabled?(cfg)
+      return false unless cfg.request_summary
+      return true if cfg.capture_rules_block
+      domain_overrides = [cfg.email_capture, cfg.sql_capture, cfg.http_capture, cfg.audit_capture, cfg.request_capture]
+      return true if domain_overrides.compact.any? { |level| level.to_s.downcase.to_sym != :none }
+
+      cfg.capture_depth.to_s.downcase.to_sym != :none
+    rescue StandardError
+      true
+    end
+
     # Set up the InstrumentationContext buffer and populate request fields.
     # Wrapped in rescue so deep capture failures never affect the host app.
     def setup_buffer(env, cfg)
       buffer = InstrumentationContext.setup(env: env)
+      return nil unless buffer
 
       buffer.request_method = env["REQUEST_METHOD"]
       buffer.request_path   = env["PATH_INFO"]
@@ -172,28 +196,25 @@ module OpenTrace
       # Never affect the host app
     end
 
-    # Capture response status, headers, and body into the buffer.
-    # For non-streaming responses, the body content is saved.
-    # For streaming responses, only Content-Length is tracked.
+    # Capture response status, headers, and size into the buffer.
+    #
+    # We intentionally do NOT call `body.to_ary` or `body.each` here. Per
+    # the Rack spec, a response body must be iterated exactly once — by the
+    # web server. Materialising it inside a middleware is a spec violation
+    # and can have surprising side-effects for wrappers that execute their
+    # source callable on iteration (observed in the wild with Falcon +
+    # async-job: calling `to_ary` here caused the downstream app to
+    # effectively run twice, duplicating ActiveJob enqueues).
+    #
+    # Size is read from the Content-Length header instead, which is the
+    # authoritative value for non-streaming responses and safely nil for
+    # streaming responses.
     def capture_response(buffer, status, headers, body)
       buffer.response_status  = status
       buffer.response_headers = headers
 
-      streaming = headers && (
-        headers["Transfer-Encoding"] == "chunked" ||
-        (headers.respond_to?(:key?) && !body.respond_to?(:to_ary))
-      )
-
-      if streaming
-        # Streaming: only track size from Content-Length header
-        buffer.response_size = headers["Content-Length"]&.to_i
-      else
-        # Non-streaming: collect body parts
-        parts = body.respond_to?(:to_ary) ? body.to_ary : []
-        collected = parts.join
-        buffer.response_body = collected unless collected.empty?
-        buffer.response_size = collected.bytesize
-      end
+      cl = headers && (headers["Content-Length"] || headers["content-length"])
+      buffer.response_size = cl.to_i if cl
     rescue StandardError
       # Never affect the host app
     end

data/lib/opentrace/payload_builder.rb

@@ -11,7 +11,11 @@ module OpenTrace
 
     def materialize(entry, config)
       if entry.is_a?(Array)
-        entry[0] == :request ? materialize_request(entry, config) : materialize_log(entry, config)
+        case entry[0]
+        when :request then materialize_request(entry, config)
+        when :raw_document then materialize_raw_document(entry[1], config)
+        else materialize_log(entry, config)
+        end
       elsif entry.is_a?(Hash)
         entry # legacy direct payload
       end
@@ -93,6 +97,72 @@ module OpenTrace
       payload
     end
 
+    def materialize_raw_document(doc, config)
+      return nil unless doc.is_a?(Hash)
+
+      req = doc[:request] || {}
+      resp = doc[:response] || {}
+      duration_ms = if doc[:duration_ms]
+                      doc[:duration_ms].to_f.round(0)
+                    elsif doc[:started_at]
+                      ((Process.clock_gettime(Process::CLOCK_MONOTONIC) - doc[:started_at]) * 1000).round(0)
+                    else
+                      0
+                    end
+
+      status = resp[:status] || resp[:response_status]
+      level = if status.to_i >= 500 then "error"
+              elsif status.to_i >= 400 then "warn"
+              else "info"
+              end
+
+      message = "#{req[:method]} #{req[:path]} #{status} #{duration_ms}ms"
+
+      payload = {
+        ts: Time.now.utc.strftime("%Y-%m-%dT%H:%M:%S.%6NZ"),
+        level: level,
+        service: config.service,
+        env: config.environment,
+        message: message,
+        event_type: "http.request",
+        method: req[:method],
+        path: req[:path],
+        status: status.to_i,
+        duration_ms: duration_ms.to_i,
+        controller: doc[:controller],
+      }
+
+      payload[:trace_id] = doc[:trace_id] if doc[:trace_id]
+      payload[:span_id] = doc[:span_id] if doc[:span_id]
+      payload[:parent_span_id] = doc[:parent_span_id] if doc[:parent_span_id]
+      payload[:request_id] = doc[:request_id] if doc[:request_id]
+
+      body = {}
+      body[:request_headers] = req[:headers] if req[:headers]
+      body[:request_params] = req[:params] if req[:params]
+      body[:request_body] = req[:body] if req[:body]
+      body[:response_headers] = resp[:headers] if resp[:headers]
+      body[:response_body] = resp[:body] if resp[:body]
+      body[:sql] = doc[:sql] if doc[:sql] && !doc[:sql].empty?
+      body[:http] = doc[:http] if doc[:http] && !doc[:http].empty?
+      body[:email] = doc[:email] if doc[:email] && !doc[:email].empty?
+      body[:audit] = doc[:audit] if doc[:audit] && !doc[:audit].empty?
+      body[:logs] = doc[:logs] if doc[:logs] && !doc[:logs].empty?
+      body[:timeline] = doc[:timeline] if doc[:timeline] && !doc[:timeline].empty?
+      body[:performance] = doc[:performance] if doc[:performance]
+      body[:context] = doc[:context] if doc[:context]
+
+      if doc[:pending_explains] && defined?(ActiveRecord::Base)
+        explain_results = run_pending_explains(doc[:pending_explains])
+        body[:queries] = explain_results unless explain_results.empty?
+      end
+
+      payload[:body] = body unless body.empty?
+      payload
+    rescue StandardError
+      nil
+    end
+
     def materialize_request(entry, config)
       _, started, finished, controller, action, method, path, status,
         exc_class, exc_message, exc_backtrace, request_id, trace_id,

data/lib/opentrace/pii_scrubber.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "set"
+
 module OpenTrace
   module PiiScrubber
     REDACTED = "[REDACTED]"

data/lib/opentrace/rails.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "set"
+
 if defined?(::Rails::Railtie)
   module OpenTrace
     class Railtie < ::Rails::Railtie

data/lib/opentrace/request_buffer.rb

@@ -9,10 +9,10 @@ module OpenTrace
     # :standard — includes captures but strips request/response bodies
     # :full     — everything
     CAPTURE_LEVELS = %i[minimal standard full].freeze
-    CAPTURE_LEVEL_RANK = { minimal: 0, standard: 1, full: 2 }.freeze
+    CAPTURE_LEVEL_RANK = { none: -1, minimal: 0, standard: 1, full: 2 }.freeze
 
     # Domains that can have individual capture-level overrides
-    DOMAINS = %i[sql http email file audit log timeline].freeze
+    DOMAINS = %i[request sql http email file audit log timeline].freeze
 
     BASE_BYTE_ESTIMATE = 1024 # 1KB base overhead
 
@@ -378,7 +378,7 @@ module OpenTrace
 
     def filter_captures(captures, domain, base_rank, domain_overrides)
       rank = resolve_domain_rank(domain, base_rank, domain_overrides)
-      return nil if rank == 0 # :minimal — strip entirely
+      return nil if rank <= 0 # :none / :minimal — strip entirely
       return captures.map(&:dup) if rank >= 2 # :full — everything
 
       # :standard — strip body fields
@@ -410,6 +410,7 @@ module OpenTrace
     end
 
     def build_request_section(base_rank, domain_overrides)
+      rank = resolve_domain_rank(:request, base_rank, domain_overrides)
       section = {
         method: @request_method,
         path: @request_path,
@@ -420,13 +421,13 @@ module OpenTrace
         size: @request_size
       }.compact
 
-      if base_rank >= 2 # :full
+      if rank >= 2 # :full
         section[:headers]     = @request_headers if @request_headers
         section[:body]        = @request_body    if @request_body
         section[:params]      = @request_params  if @request_params
         section[:cookies]     = @cookies         if @cookies
         section[:session_data] = @session_data   if @session_data
-      elsif base_rank >= 1 # :standard — params but no body
+      elsif rank >= 1 # :standard — params but no body
         section[:params]      = @request_params  if @request_params
       end
 
@@ -434,12 +435,13 @@ module OpenTrace
     end
 
     def build_response_section(base_rank, domain_overrides)
+      rank = resolve_domain_rank(:request, base_rank, domain_overrides)
       section = {
         status: @response_status,
         size: @response_size
       }.compact
 
-      if base_rank >= 2 # :full
+      if rank >= 2 # :full
         section[:headers] = @response_headers if @response_headers
         section[:body]    = @response_body    if @response_body
       end

data/lib/opentrace/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module OpenTrace
-  VERSION = "0.17.0"
+  VERSION = "0.17.3"
 end

data/lib/opentrace.rb

@@ -61,6 +61,7 @@ module OpenTrace
     def configure
       yield config
       config.finalize!
+      InstrumentationContext.configure!(config)
       reset_client!
     end
 
@@ -289,61 +290,12 @@ module OpenTrace
     end
 
     # Enqueue a raw request buffer document (from InstrumentationContext).
-    # Converts the nested buffer doc to flat format before enqueueing.
+    # Defers conversion to the background dispatch thread.
     def client_enqueue_raw(doc)
       return unless enabled?
+      return unless doc.is_a?(Hash)
 
-      req = doc[:request] || {}
-      resp = doc[:response] || {}
-      duration_ms = if doc[:started_at]
-                      ((Process.clock_gettime(Process::CLOCK_MONOTONIC) - doc[:started_at]) * 1000).round(0)
-                    end
-
-      status = resp[:status] || resp[:response_status]
-      level = if status.to_i >= 500 then "error"
-             elsif status.to_i >= 400 then "warn"
-             else "info"
-             end
-
-      message = "#{req[:method]} #{req[:path]} #{status} #{duration_ms}ms"
-
-      payload = {
-        ts: Time.now.utc.strftime("%Y-%m-%dT%H:%M:%S.%6NZ"),
-        level: level,
-        service: config.service,
-        env: config.environment,
-        message: message,
-        event_type: "http.request",
-        method: req[:method],
-        path: req[:path],
-        status: status.to_i,
-        duration_ms: duration_ms.to_i,
-        controller: doc[:controller],
-      }
-
-      payload[:trace_id] = doc[:trace_id] if doc[:trace_id]
-      payload[:span_id] = doc[:span_id] if doc[:span_id]
-      payload[:parent_span_id] = doc[:parent_span_id] if doc[:parent_span_id]
-      payload[:request_id] = doc[:request_id] if doc[:request_id]
-
-      # Pack everything else into body
-      body = {}
-      body[:request_headers] = req[:headers] if req[:headers]
-      body[:request_params] = req[:params] if req[:params]
-      body[:request_body] = req[:body] if req[:body]
-      body[:response_headers] = resp[:headers] if resp[:headers]
-      body[:response_body] = resp[:body] if resp[:body]
-      body[:sql] = doc[:sql] if doc[:sql] && !doc[:sql].empty?
-      body[:http] = doc[:http] if doc[:http] && !doc[:http].empty?
-      body[:email] = doc[:email] if doc[:email] && !doc[:email].empty?
-      body[:audit] = doc[:audit] if doc[:audit] && !doc[:audit].empty?
-      body[:logs] = doc[:logs] if doc[:logs] && !doc[:logs].empty?
-      body[:timeline] = doc[:timeline] if doc[:timeline] && !doc[:timeline].empty?
-      body[:performance] = doc[:performance] if doc[:performance]
-      body[:context] = doc[:context] if doc[:context]
-
-      payload[:body] = body unless body.empty?
-      client.enqueue(payload)
+      client.enqueue([:raw_document, doc])
     rescue StandardError
       # Never raise to the host app
     end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: opentrace
 version: !ruby/object:Gem::Version
-  version: 0.17.0
+  version: 0.17.3
 platform: ruby
 authors:
 - OpenTrace