opentrace 0.8.0 → 0.12.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fd043296872a0f5241acc4f8331bc2d6c6f7e39628e0501fc6e0480af7c423f9
-  data.tar.gz: b37915c9ed52898d6607a668c264c573f8d2012d937ec4053712ff2c65fb741e
+  metadata.gz: f91e8fcf70aeeb601265b588138c85d00c5a96d034278caa4226072eb75c440d
+  data.tar.gz: ed9d094bf4af6d4545f70d464753bfd594e4d0ddf5758a977e6205bc2d6ad4ef
 SHA512:
-  metadata.gz: a9567eefab80204781b112f43f915a755ad55327eef2255b7b9c655da9eb36e4eed55c6617e1711d00bbd74ec9dd1f88332b0f0c0c4e2e0562e75a1fdcb8a9fe
-  data.tar.gz: 11bf43482a27798a4bcf20c7cb700a565692d2b863d3011feb403df97e039b2b75cd35e0e53f12d7b17a107b7d07ef1959c0539d9507397376bb8901afcb9346
+  metadata.gz: 56a8cea4c49c71aa18b467e041ceba338646883cc9b158d9b28efea5d741148b08e911c762f7a596b9ec7edfd93804875a14f0038e5bee08333c81afeb52865b
+  data.tar.gz: 7f66b1c9f6b55a37e1bfe2adbe2731f4e87b32eeab068287782b8abbd734a2f9930dccfb68f2fe2e84f2e67ac85798b91abe44262b7f46c3d83a3d3e439cdf97

data/lib/opentrace/breadcrumbs.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module OpenTrace
+  class Breadcrumb
+    attr_reader :category, :message, :data, :timestamp, :level
+
+    def initialize(category:, message:, data: nil, level: "info")
+      @category = category.to_s
+      @message = message.to_s
+      @data = data
+      @level = level.to_s
+      @timestamp = Process.clock_gettime(Process::CLOCK_REALTIME)
+    end
+
+    def to_h
+      h = { category: @category, message: @message, level: @level, timestamp: @timestamp }
+      h[:data] = @data if @data
+      h
+    end
+  end
+
+  class BreadcrumbBuffer
+    MAX_BREADCRUMBS = 25
+
+    def initialize
+      @buffer = []
+    end
+
+    def add(breadcrumb)
+      @buffer.shift if @buffer.size >= MAX_BREADCRUMBS
+      @buffer << breadcrumb
+    end
+
+    def to_a
+      @buffer.map(&:to_h)
+    end
+
+    def empty?
+      @buffer.empty?
+    end
+
+    def size
+      @buffer.size
+    end
+  end
+end

data/lib/opentrace/client.rb

@@ -16,8 +16,9 @@ module OpenTrace
 
     attr_reader :stats
 
-    def initialize(config)
+    def initialize(config, sampler: nil)
       @config = config
+      @sampler = sampler
       @queue  = Thread::Queue.new
       @mutex  = Mutex.new
       @thread = nil
@@ -140,6 +141,16 @@ module OpenTrace
         next if batch.empty?
 
         send_batch(batch)
+
+        # Adjust backpressure based on queue depth
+        if @sampler
+          queue_pct = @queue.size.to_f / MAX_QUEUE_SIZE
+          if queue_pct > 0.75
+            @sampler.increase_backpressure!
+          elsif queue_pct < 0.25
+            @sampler.decrease_backpressure!
+          end
+        end
       end
     rescue Exception # rubocop:disable Lint/RescueException
       # Swallow all errors including thread kill
@@ -212,8 +223,25 @@ module OpenTrace
       # Disable HTTP tracking for our own calls to prevent infinite recursion
       Fiber[:opentrace_http_tracking_disabled] = true
 
-      # Apply per-payload truncation
-      batch = batch.map { |p| fit_payload(p) }.compact
+      # Materialize deferred entries + apply before_send filter + truncate
+      batch = batch.filter_map do |item|
+        payload = PayloadBuilder.materialize(item, @config)
+        next nil unless payload
+        if @config.before_send
+          payload = @config.before_send.call(payload) rescue payload
+          unless payload
+            @stats.increment(:dropped_filtered)
+            next nil
+          end
+        end
+        # PII scrubbing (runs on background thread)
+        if @config.pii_scrubbing && payload[:metadata]
+          active_patterns = build_pii_patterns
+          PiiScrubber.scrub!(payload[:metadata], patterns: active_patterns)
+        end
+
+        fit_payload(payload)
+      end
       return if batch.empty?
 
       json = JSON.generate(batch)
@@ -227,7 +255,11 @@ module OpenTrace
         return
       end
 
-      response = send_with_retry(json)
+      response = if @config.transport == :unix_socket
+                   unix_socket_send(json)
+                 else
+                   send_with_retry(json)
+                 end
       handle_response(response, batch, json.bytesize)
     rescue StandardError
       @circuit_breaker.record_failure
@@ -251,6 +283,7 @@ module OpenTrace
         @stats.increment(:delivered, batch.size)
         @stats.increment(:batches_sent)
         @stats.increment(:bytes_sent, bytes)
+        @config.after_send&.call(batch.size, bytes) rescue nil
       when Net::HTTPTooManyRequests
         handle_rate_limit(response, batch)
       when Net::HTTPUnauthorized
@@ -351,6 +384,32 @@ module OpenTrace
       persistent_http.request(request)
     end
 
+    def unix_socket_send(json)
+      payload = if @config.compression && json.bytesize > @config.compression_threshold
+                  gzip_compress(json)
+                else
+                  json
+                end
+
+      socket = UNIXSocket.new(@config.socket_path)
+      # Protocol: 4-byte big-endian length prefix + payload
+      socket.write([payload.bytesize].pack("N"))
+      socket.write(payload)
+      socket.flush
+
+      # Read 4-byte status code response
+      response_data = socket.read(4)
+      status = response_data&.unpack1("N") || 500
+      socket.close
+
+      UnixSocketResponse.new(status)
+    rescue Errno::ECONNREFUSED, Errno::ENOENT, Errno::ENOTSOCK
+      # Socket not available — fall back to HTTP
+      send_with_retry(json)
+    rescue StandardError
+      nil
+    end
+
     def retryable_response?(response)
       response.code.to_i >= 500
     end
@@ -394,6 +453,22 @@ module OpenTrace
       io.string
     end
 
+    def build_pii_patterns
+      patterns = PiiScrubber::PATTERNS.dup
+      # Remove disabled patterns
+      if @config.pii_disabled_patterns
+        @config.pii_disabled_patterns.each { |name| patterns.delete(name) }
+      end
+      result = patterns.values
+      # Add custom patterns
+      if @config.pii_patterns
+        result.concat(@config.pii_patterns)
+      end
+      result
+    rescue StandardError
+      PiiScrubber::PATTERNS.values
+    end
+
     def fire_on_drop(count, reason)
       @config.on_drop&.call(count, reason)
     rescue StandardError
@@ -458,6 +533,20 @@ module OpenTrace
       http.request(request)
     end
 
+    # Adapts a numeric status code from Unix socket into Net::HTTP response duck type
+    UnixSocketResponse = Struct.new(:code) do
+      def is_a?(klass)
+        c = code.to_i
+        case klass.name
+        when "Net::HTTPSuccess"          then c >= 200 && c < 300
+        when "Net::HTTPTooManyRequests"  then c == 429
+        when "Net::HTTPUnauthorized"     then c == 401
+        when "Net::HTTPServerError"      then c >= 500 && c < 600
+        else super
+        end
+      end
+    end
+
     def truncate_payload(payload)
       meta = payload[:metadata]&.dup || {}
 

data/lib/opentrace/config.rb

@@ -4,9 +4,10 @@ module OpenTrace
   class Config
     REQUIRED_FIELDS = %i[endpoint api_key service].freeze
     LEVELS = { debug: 0, info: 1, warn: 2, error: 3, fatal: 4 }.freeze
+    LEVEL_INTS = { "DEBUG" => 0, "INFO" => 1, "WARN" => 2, "ERROR" => 3, "FATAL" => 4 }.freeze
 
     attr_accessor :endpoint, :api_key, :service, :environment, :timeout, :enabled,
-                  :context, :min_level, :allowed_levels, :hostname, :pid, :git_sha,
+                  :context, :hostname, :pid, :git_sha,
                   :batch_size, :flush_interval,
                   :max_retries, :retry_base_delay, :retry_max_delay,
                   :circuit_breaker_threshold, :circuit_breaker_timeout,
@@ -14,7 +15,6 @@ module OpenTrace
                   :on_drop,
                   :compression, :compression_threshold,
                   :sql_logging, :sql_duration_threshold_ms,
-                  :ignore_paths,
                   :pool_monitoring, :pool_monitoring_interval,
                   :queue_monitoring, :queue_monitoring_interval,
                   :request_summary, :timeline, :timeline_max_events,
@@ -22,7 +22,34 @@ module OpenTrace
                   :max_payload_bytes,
                   :trace_propagation,
                   :log_forwarding, :view_tracking, :cache_tracking,
-                  :deprecation_tracking, :detailed_request_log
+                  :deprecation_tracking, :detailed_request_log,
+                  :sample_rate, :sampler, :before_send,
+                  :sql_normalization, :log_trace_injection,
+                  :source_context, :before_breadcrumb,
+                  :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
+
+    # Custom writers that invalidate the level cache
+    attr_reader :min_level, :allowed_levels, :ignore_paths
+
+    def min_level=(val)
+      @min_level = val
+      @level_cache = nil
+    end
+
+    def allowed_levels=(val)
+      @allowed_levels = val
+      @level_cache = nil
+    end
+
+    def ignore_paths=(val)
+      @ignore_paths = val
+    end
 
     def initialize
       @endpoint    = nil
@@ -50,7 +77,7 @@ module OpenTrace
       @compression_threshold = 1024 # only compress payloads > 1KB
       @sql_logging    = false
       @sql_duration_threshold_ms = 0.0
-      @ignore_paths   = []
+      @ignore_paths   = %w[/up /health /healthz /ping /ready /livez /readyz]
       @pool_monitoring = false
       @pool_monitoring_interval = 30
       @queue_monitoring = false
@@ -67,6 +94,27 @@ module OpenTrace
       @cache_tracking = false
       @deprecation_tracking = false
       @detailed_request_log = false
+      @sample_rate = 1.0     # Float 0.0-1.0, default 1.0 (all requests)
+      @sampler     = nil     # Proc(env) -> Float, for per-endpoint rates
+      @before_send = nil     # Proc(payload) -> payload|nil, filter/drop
+      @sql_normalization = true   # Normalize SQL queries (replace literals with ?)
+      @log_trace_injection = false # Inject trace_id/request_id into Rails logger
+      @source_context = false      # Capture source code context around errors
+      @before_breadcrumb = nil     # Proc(Breadcrumb) -> Breadcrumb|nil
+      @pii_scrubbing = false       # Scrub PII from metadata before sending
+      @pii_patterns = nil          # Array of additional Regexp patterns
+      @pii_disabled_patterns = nil # Array of Symbol pattern names to skip
+      @session_tracking = false    # Extract session ID from cookies
+      @on_error = nil              # Proc(exception, metadata) — called on error capture
+      @after_send = nil            # Proc(batch_size, bytes) — called after successful delivery
+      @transport = :http              # :http | :unix_socket
+      @socket_path = "/tmp/opentrace.sock" # Unix socket path
+      @local_vars_capture = false     # Capture local variables via explicit binding
+      @explain_slow_queries = false   # Run EXPLAIN on slow SQL queries
+      @explain_threshold_ms = 100.0   # Threshold for EXPLAIN capture
+      @runtime_metrics = false        # Collect GC/runtime metrics
+      @runtime_metrics_interval = 30  # Interval in seconds
+      @level_cache = nil
     end
 
     def valid?
@@ -81,12 +129,27 @@ module OpenTrace
       LEVELS[min_level.to_s.downcase.to_sym] || 0
     end
 
+    # Hot path: single hash lookup, zero allocations for known levels.
+    # Cache is built lazily on first call and invalidated when
+    # min_level or allowed_levels change.
     def level_allowed?(level)
-      if allowed_levels
-        allowed_levels.map { |l| l.to_s.upcase }.include?(level.to_s.upcase)
-      else
-        (LEVELS[level.to_s.downcase.to_sym] || 0) >= min_level_value
+      cache = @level_cache
+      unless cache
+        build_level_cache!
+        cache = @level_cache
       end
+      key = level.to_s.upcase
+      result = cache[key]
+      return result unless result.nil?
+      # Unknown level (e.g. "UNKNOWN"): treat as severity 0
+      return false if allowed_levels # not in the allowed list
+      0 >= (LEVELS[min_level.to_s.downcase.to_sym] || 0)
+    end
+
+    # Pre-compute the level cache. Called at end of configure block
+    # and lazily when settings change afterward.
+    def finalize!
+      build_level_cache!
     end
 
     # Maps OpenTrace min_level to Ruby Logger severity constant.
@@ -103,5 +166,20 @@ module OpenTrace
     def logger_severity
       LEVEL_TO_LOGGER_SEVERITY[min_level.to_s.downcase.to_sym] || 0
     end
+
+    private
+
+    def build_level_cache!
+      min_int = LEVELS[min_level.to_s.downcase.to_sym] || 0
+      if allowed_levels
+        @level_cache = allowed_levels.each_with_object({}) do |l, h|
+          h[l.to_s.upcase] = true
+        end.freeze
+      else
+        @level_cache = LEVEL_INTS.each_with_object({}) do |(k, v), h|
+          h[k] = v >= min_int
+        end.freeze
+      end
+    end
   end
 end

data/lib/opentrace/local_vars.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module OpenTrace
+  module LocalVars
+    MAX_VARS = 10
+    MAX_VALUE_LENGTH = 500
+
+    module_function
+
+    # Capture local variables from an explicit binding.
+    # Called by the user in their rescue blocks:
+    #
+    #   rescue => e
+    #     OpenTrace.capture_binding(e, binding)
+    #     raise
+    #   end
+    #
+    # Returns: Array of { name:, value:, type: } or nil
+    def capture(binding_obj)
+      return nil unless binding_obj.is_a?(Binding)
+
+      vars = binding_obj.local_variables.first(MAX_VARS)
+      vars.filter_map do |name|
+        # Skip internal variables (_, _1, etc.)
+        next if name.to_s.start_with?("_")
+
+        value = binding_obj.local_variable_get(name)
+        {
+          name: name.to_s,
+          value: safe_inspect(value),
+          type: value.class.name
+        }
+      end
+    rescue StandardError
+      nil
+    end
+
+    def safe_inspect(value)
+      str = value.inspect
+      str.length > MAX_VALUE_LENGTH ? str[0, MAX_VALUE_LENGTH] + "..." : str
+    rescue StandardError
+      "#<uninspectable>"
+    end
+  end
+end

data/lib/opentrace/middleware.rb

@@ -13,6 +13,13 @@ module OpenTrace
       # When OpenTrace is disabled, pass through with zero overhead
       return @app.call(env) unless OpenTrace.enabled?
 
+      # Sampling: skip ALL Fiber-local setup for unsampled requests.
+      # Subscribers check Fiber-locals and return instantly when nil.
+      unless OpenTrace.sampler.sample?(env)
+        OpenTrace.send(:client).stats.increment(:sampled_out)
+        return @app.call(env)
+      end
+
       request_id = env["action_dispatch.request_id"] || env["HTTP_X_REQUEST_ID"]
       OpenTrace.current_request_id = request_id
       Fiber[:opentrace_sql_count] = 0
@@ -28,6 +35,12 @@ module OpenTrace
         Fiber[:opentrace_parent_span_id] = parent_span_id
       end
 
+      # Session tracking (opt-in)
+      if OpenTrace.config.session_tracking
+        session_id = extract_session_id(env)
+        Fiber[:opentrace_session_id] = session_id if session_id
+      end
+
       # Create RequestCollector only when features that need it are enabled
       cfg = OpenTrace.config
       needs_collector = cfg.request_summary &&
@@ -59,6 +72,10 @@ module OpenTrace
       Fiber[:opentrace_trace_id] = nil
       Fiber[:opentrace_span_id] = nil
       Fiber[:opentrace_parent_span_id] = nil
+      Fiber[:opentrace_transaction_name] = nil
+      Fiber[:opentrace_breadcrumbs] = nil
+      Fiber[:opentrace_session_id] = nil
+      Fiber[:opentrace_pending_explains] = nil
       OpenTrace.current_request_id = nil
     end
 
@@ -94,6 +111,25 @@ module OpenTrace
       [TraceContext.generate_trace_id, nil]
     end
 
+    def extract_session_id(env)
+      # Try Rack session first
+      if (session = env["rack.session"])
+        return session.id.to_s if session.respond_to?(:id) && session.id
+      end
+
+      # Fall back to session cookie
+      cookie_name = env.dig("rack.session.options", :key) || "_session_id"
+      cookies = env["HTTP_COOKIE"]
+      if cookies
+        match = cookies.match(/#{Regexp.escape(cookie_name)}=([^;]+)/)
+        return match[1] if match
+      end
+
+      nil
+    rescue StandardError
+      nil
+    end
+
     def current_rss_mb
       if RUBY_PLATFORM.include?("linux")
         # Linux: read from /proc — no fork, ~10μs

data/lib/opentrace/payload_builder.rb

@@ -0,0 +1,227 @@
+# frozen_string_literal: true
+
+module OpenTrace
+  # Materializes deferred log entries (frozen Arrays) into payload Hashes.
+  # All heavy work (context merge, timestamp formatting, Hash building)
+  # runs on the background dispatch thread, keeping the request thread fast.
+  module PayloadBuilder
+    module_function
+
+    def materialize(entry, config)
+      if entry.is_a?(Array)
+        entry[0] == :request ? materialize_request(entry, config) : materialize_log(entry, config)
+      elsif entry.is_a?(Hash)
+        entry # legacy direct payload
+      end
+    rescue StandardError
+      nil
+    end
+
+    def materialize_log(entry, config)
+      ts, level, message, metadata, ctx, request_id, trace_id,
+        span_id, parent_span_id, req_summary, event_type = entry
+
+      meta = ctx.is_a?(Hash) ? ctx.dup : {}
+      meta.merge!(metadata) if metadata.is_a?(Hash)
+
+      static_ctx = OpenTrace.send(:static_context)
+      static_ctx.each { |k, v| meta[k] ||= v }
+      meta[:request_id] ||= request_id if request_id
+
+      # Extract trace_id from metadata if user provided it there
+      meta_trace_id = meta.delete(:trace_id)
+      effective_trace_id = meta_trace_id || trace_id
+
+      payload = {
+        timestamp: format_timestamp(ts),
+        level: level.to_s.upcase,
+        service: config.service,
+        environment: config.environment,
+        message: message.to_s,
+        metadata: meta.compact
+      }
+
+      payload[:event_type] = event_type.to_s if event_type
+      payload[:trace_id] = effective_trace_id.to_s if effective_trace_id
+      payload[:span_id] = span_id if span_id
+      payload[:parent_span_id] = parent_span_id if parent_span_id
+      payload[:request_summary] = req_summary if req_summary
+      payload
+    end
+
+    def materialize_request(entry, config)
+      _, started, finished, controller, action, method, path, status,
+        exc_class, exc_message, exc_backtrace, request_id, trace_id,
+        span_id, parent_span_id, cached_ctx, collector, extra = entry
+
+      duration_ms = (finished && started) ? (finished - started) * 1000.0 : 0.0
+
+      meta = cached_ctx.is_a?(Hash) ? cached_ctx.dup : {}
+      meta.merge!(extra) if extra.is_a?(Hash)
+
+      static_ctx = OpenTrace.send(:static_context)
+      static_ctx.each { |k, v| meta[k] ||= v }
+      meta[:request_id] ||= request_id if request_id
+
+      if cached_ctx.is_a?(Hash) && cached_ctx.key?(:user_id)
+        meta[:user_id] = cached_ctx[:user_id]
+      end
+
+      if exc_class
+        meta[:exception_class] = exc_class
+        meta[:exception_message] = exc_message&.slice(0, 500)
+        if exc_backtrace
+          cleaned = clean_backtrace(exc_backtrace)
+          meta[:backtrace] = cleaned.first(15)
+          meta[:error_fingerprint] = OpenTrace.send(:compute_error_fingerprint, exc_class, cleaned)
+        end
+      end
+
+      # Run deferred EXPLAIN on background thread
+      if extra.is_a?(Hash) && extra[:pending_explains] && defined?(ActiveRecord::Base)
+        explain_results = run_pending_explains(extra.delete(:pending_explains))
+        meta[:explain_plans] = explain_results unless explain_results.empty?
+      end
+
+      # Build request_summary from collector
+      request_summary = nil
+      if collector
+        summary = collector.summary
+        request_summary = build_request_summary(collector, summary, controller, action, method, path, status, duration_ms)
+      else
+        # No collector — include request identity in metadata
+        meta[:controller] = controller
+        meta[:action] = action
+        meta[:method] = method
+        meta[:path] = path
+        meta[:status] = status
+        meta[:duration_ms] = duration_ms.round(1)
+      end
+
+      level = if exc_class
+                "ERROR"
+              elsif status.to_i >= 500
+                "ERROR"
+              elsif status.to_i >= 400
+                "WARN"
+              else
+                "INFO"
+              end
+
+      # Use custom transaction name if set
+      transaction_name = meta.delete(:transaction_name)
+      message = if transaction_name
+                  "#{transaction_name} #{status} #{duration_ms.round(1)}ms"
+                else
+                  "#{method} #{path} #{status} #{duration_ms.round(1)}ms"
+                end
+      meta[:transaction_name] = transaction_name if transaction_name
+
+      payload = {
+        timestamp: format_timestamp(started),
+        level: level,
+        service: config.service,
+        environment: config.environment,
+        message: message,
+        metadata: meta.compact
+      }
+      payload[:trace_id] = trace_id.to_s if trace_id
+      payload[:span_id] = span_id if span_id
+      payload[:parent_span_id] = parent_span_id if parent_span_id
+      payload[:request_summary] = request_summary if request_summary
+      payload
+    end
+
+    def format_timestamp(ts)
+      case ts
+      when Float
+        Time.at(ts).utc.strftime("%Y-%m-%dT%H:%M:%S.%6NZ")
+      when Time
+        ts.utc.strftime("%Y-%m-%dT%H:%M:%S.%6NZ")
+      else
+        Time.now.utc.strftime("%Y-%m-%dT%H:%M:%S.%6NZ")
+      end
+    end
+
+    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 run_pending_explains(pending)
+      pending.filter_map do |entry|
+        plan = run_explain(entry[:sql])
+        next unless plan
+        {
+          sql: entry[:sql].to_s.slice(0, 500),
+          duration_ms: entry[:duration_ms],
+          name: entry[:name],
+          explain_plan: plan
+        }
+      end
+    rescue StandardError
+      []
+    end
+
+    def run_explain(sql)
+      ActiveRecord::Base.connection_pool.with_connection do |conn|
+        result = conn.execute("EXPLAIN #{sql}")
+        rows = result.respond_to?(:rows) ? result.rows : result.map(&:values)
+        rows.flatten.join("\n").slice(0, 2000)
+      end
+    rescue StandardError
+      nil
+    end
+
+    def build_request_summary(collector, summary, controller, action, method, path, status, duration_ms)
+      rs = {
+        controller: controller,
+        action: action,
+        method: method,
+        path: path,
+        status: status,
+        duration_ms: duration_ms.round(1),
+        sql_count: summary[:sql_query_count],
+        sql_total_ms: summary[:sql_total_ms],
+        sql_slowest_ms: summary[:sql_slowest_ms],
+        sql_slowest_name: summary[:sql_slowest_name],
+        n_plus_one: summary[:n_plus_one_warning] || false,
+        view_count: summary[:view_render_count],
+        view_total_ms: summary[:view_total_ms],
+        view_slowest_ms: summary[:view_slowest_ms],
+        view_slowest_template: summary[:view_slowest_template],
+        cache_reads: summary[:cache_reads],
+        cache_hits: summary[:cache_hits],
+        cache_writes: summary[:cache_writes],
+        cache_hit_ratio: summary[:cache_hit_ratio],
+        http_external_count: summary[:http_external_count],
+        http_external_total_ms: summary[:http_external_total_ms],
+        http_slowest_ms: summary[:http_slowest_ms],
+        http_slowest_host: summary[:http_slowest_host],
+        memory_before_mb: summary[:memory_before_mb],
+        memory_after_mb: summary[:memory_after_mb],
+        memory_delta_mb: summary[:memory_delta_mb],
+        timeline: summary[:timeline]
+      }.compact
+
+      # Compute time breakdown
+      if duration_ms > 0
+        sql_pct = [((collector.sql_total_ms / duration_ms) * 100).round(1), 100.0].min
+        view_pct = [((collector.view_total_ms / duration_ms) * 100).round(1), 100.0].min
+        http_pct = collector.http_count > 0 ? [((collector.http_total_ms / duration_ms) * 100).round(1), 100.0].min : 0.0
+        other_pct = [100 - sql_pct - view_pct - http_pct, 0].max.round(1)
+        rs[:time_breakdown] = {
+          sql_pct: sql_pct,
+          view_pct: view_pct,
+          http_pct: http_pct,
+          other_pct: other_pct
+        }
+      end
+
+      rs
+    end
+  end
+end