dead_bro 0.2.36 → 0.2.38

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7f33da7799522248140cc65b3637ae2a1dede4295b3696370bd3aabea0d09c7b
-  data.tar.gz: 376071ecd3eafe0e41695246074ccea3b3a2c479532d08eb24d46fa0d471c94e
+  metadata.gz: 4258f98fde5b0e222593ebfadee095b6402576d94a33a2b57ac26c71f0b75d47
+  data.tar.gz: 4a268f4eb24b882bf2dddd36a45db694f664319d3fa9650c3587eb59dd37f2af
 SHA512:
-  metadata.gz: ba9539bb294999bcd1d3b1f4bed9bc7612d4b9f3e66fe92769de92a0b50d8991ffadf2daf6e418b3951fcda7b8e1ae9afa5b6980c4de7af49d982ccd07aff6f2
-  data.tar.gz: 1e9abbd0ef17016ea6f639fa60d6d18edc0b481cdeec3d6495f52f5ae31e73a413db0bb7e7607b274a344d8ab1b33dda098dca608c617a024622aff3796fc8e0
+  metadata.gz: 94f6cccf6594f0c50467b61a5d2bf53d6b73e7e72e6f042c2eae3cea2bad12e674e8a2f525bb7880f51f3b6cc679e3f3951dfba224b07e9701b48669060ffd51
+  data.tar.gz: eae0e565ae2d1b43f20df7c3fd14311c7543f29b1680f0495c1fa1b4ca86a30c880b20dc94ba9cc147288dff41fa39eb7aae360dafb76139b751dccc380d02e4

data/CHANGELOG.md

@@ -1,5 +1,28 @@
 ## [Unreleased]
 
+## [0.2.38] - 2026-10-26
+
+### Added
+- **Nested Request Trace.** Each request now sends its span tree as `spans`: the Rack middleware chain, the router, the controller action, view renders (layouts, templates, partials and collections), `DeadBro.watch` blocks, the block a `Rails.cache.fetch` miss runs, and SQL queries, each with an `id` and the id of the span it ran inside (`parent_id`). Repeated calls on the same path share one span with a `count`: a partial rendered 50 times from one template is one span, and the query it runs each time is one span under it. A span's `total_ms` is its calls' summed time with the spans nested in it included, and `start_ms` / `end_ms` are its first call's start and its last call's end. Cache, Redis, HTTP, Elasticsearch and transaction events carry the `parent_id` of the span they ran in, the cache event of a `Rails.cache.fetch` block and `DeadBro.watch` events the `span_id` of their span, and `sql_queries` entries the `id` their SQL spans refer to. DeadBro shows the tree with each span's total time and self time (total minus the spans nested in it). Up to 500 spans are kept per request; `spans_dropped` counts the ones left out. Background jobs don't send `spans`. An action that uses `ActionController::Live` runs on a thread of its own; its spans are recorded there, without the middleware chain.
+- **Middleware timing.** Each middleware of the app's Rails middleware stack and the router it ends in are timed as spans, so the trace shows the time each one spends before and after the app. The dashboard's middleware spans setting turns their recording off and on without a restart, and `config.middleware_spans_enabled = false` in an initializer leaves the middleware stack as Rails builds it, without the probes. Either way, the trace then starts at the controller action.
+
+### Changed
+- A request's payload is sent once the outermost middleware has returned instead of when the controller action finishes, so that the middleware spans are complete. If that middleware never returns through DeadBro's probe, for example when a timeout outside the Rails middleware stack raises into the thread at that moment, the payload is sent when the thread's next request comes in, and the next request's spans start afresh.
+
+### Fixed
+- **An HTTP request made through Faraday was recorded twice:** once by DeadBro's Faraday middleware and once by its `Net::HTTP` or Typhoeus hook underneath, so its time was counted twice. It is now recorded once, by the Faraday middleware, which also sends the request's start offset and exception class as the `Net::HTTP` hook does. Elasticsearch requests sent through Faraday are recorded once too. A request the Faraday middleware leaves out (one to localhost) is still left to the `Net::HTTP` or Typhoeus hook, as before.
+
+## [0.2.37] - 2026-10-26
+
+### Fixed
+- **`sql_count` stopped at 100 on any page that ran more queries.** It was never a query count: the subscriber read `ActiveRecord::Base.connection.query_cache.size`, the number of distinct SELECTs in the query cache — an LRU capped at 100 entries since Rails 7.1. An N+1 page that ran 188 queries reported "SQL Count 100" and "100 calls/request". `sql_count` is now the sum of the per-statement aggregate counts the SQL subscriber already keeps (every query, not only the first `MAX_TRACKED_QUERIES`), with query-cache hits included the way Rails counts them in its `(N queries, M cached)` log line. The old lookup also leased a database connection on requests that ran no SQL; nothing in the subscriber touches `ActiveRecord::Base.connection` any more.
+- Background jobs sent no `sql_count` at all, so the dashboard showed 0 database calls for every job; job payloads now carry the same count.
+
+### Added
+- `sql_cached_count` on request and job payloads: how many of `sql_count` were answered by the query cache.
+
+## [0.2.36] - 2026-10-25
+
 ### Added
 - **`gc_pressure` now says whether the window's GC had finished.** `gc_state_at_end` is the GC's phase when a request or job window closes — `"none"`, `"marking"` or `"sweeping"`, from `GC.latest_gc_info(:state)` — sent with the other memory-tracking fields. Ruby marks and sweeps in steps between allocations, so a GC counted in the window is often still running when it closes, and until it finishes `heap_live_slots_growth` still counts garbage it hasn't freed. The dashboard uses it so a sample measured mid-GC isn't flagged as a possible leak. It's a single-key read; no hash is built.
 

data/README.md

@@ -118,6 +118,20 @@ DeadBro automatically tracks view rendering performance for each request. This i
 - **Slow view detection**: Identification of the slowest rendering views
 - **Frequency analysis**: Most frequently rendered views
 
+## Request Trace (span tree)
+
+Each web request carries its span tree as `spans`, which DeadBro shows as a nested Request Trace with each span's total and self time:
+
+- **Spans**: every middleware of the Rails middleware stack and the router it ends in, the controller action, view renders (layouts, templates, partials, collections), `DeadBro.watch` blocks, the block a `Rails.cache.fetch` miss runs, and SQL queries. Each has an `id`, the `parent_id` of the span it ran inside (`nil` at the top) and a `kind` (`middleware`, `endpoint`, `action`, `view`, `watch`, `cache`, `sql`).
+- **Repeated calls**: calls with the same name under the same parent share one span with a `count`. A partial rendered 50 times from one template is one span; the query it runs each time is one span under it. `Rails.cache.fetch` blocks whose keys differ only in their digits share one span, named by the key with each run of digits as `?`.
+- **Times**: `total_ms` is the calls' summed duration, nested spans included; `start_ms` and `end_ms` are the first call's start and the last call's end, as offsets from the request's tracking start like every `start_offset_ms` (middleware that runs before DeadBro's own has negative offsets).
+- **Other events**: cache, Redis, HTTP, Elasticsearch and transaction events stay in their own lists and carry the `parent_id` of the span they ran in. The cache event of a `Rails.cache.fetch` block and `DeadBro.watch` events carry the `span_id` of their span, and SQL spans refer to their `sql_queries` entry by `ref`.
+- **Limits**: up to 500 spans per request; `spans_dropped` counts the ones left out, whose time stays in their parent's self time.
+
+Middleware is timed by a probe Rails places around each middleware when it builds the middleware stack. The middleware stack returns after the controller action has finished, so a request's payload is sent once the outermost middleware has returned. An action that uses `ActionController::Live` runs on a thread of its own, and its spans are recorded there, without the middleware chain. Background jobs don't send `spans`.
+
+The dashboard's **Middleware spans** setting (`middleware_spans_enabled`, on by default) turns their recording off and on without a restart. While it's off, the probes stay in place but record nothing: the trace starts at the controller action, and a request's payload is sent when the action finishes. To leave the middleware stack as Rails builds it, without the probes, set `config.middleware_spans_enabled = false` in `config/initializers/dead_bro.rb` (default `true`). It's read when Rails builds the middleware stack, after the app's initializers have run, so a change takes effect when the app restarts; while it's `false`, the dashboard setting can't turn the spans on.
+
 ## Memory Tracking & Leak Detection
 
 DeadBro automatically tracks memory usage and detects memory leaks with minimal performance impact. This includes:

data/lib/dead_bro/cache_subscriber.rb

@@ -69,7 +69,7 @@ module DeadBro
     def self.build_event(name, data, duration_ms, start_offset_ms = nil)
       return nil unless data.is_a?(Hash)
 
-      {
+      event = {
         event: name,
         duration_ms: duration_ms,
         start_offset_ms: start_offset_ms,
@@ -80,6 +80,17 @@ module DeadBro
         namespace: safe_namespace(data[:namespace]),
         at: Time.now.utc.to_i
       }
+      # A Rails.cache.fetch block is a span of the request's tree: its event
+      # names that span, which ran in the span the event's parent_id gives.
+      node = DeadBro::SpanTracker.cache_node(data)
+      if node
+        event[:span_id] = node[:id]
+        event[:parent_id] = node[:parent_id] if node[:parent_id]
+      else
+        parent_id = DeadBro::SpanTracker.current_id
+        event[:parent_id] = parent_id if parent_id
+      end
+      event
     rescue
       nil
     end

data/lib/dead_bro/configuration.rb

@@ -19,6 +19,14 @@ module DeadBro
     alias_method :explain_analyze_enabled, :explain_enabled
     alias_method :explain_analyze_enabled=, :explain_enabled=
 
+    # Middleware spans. false in the app's initializer leaves the middleware
+    # stack as Rails builds it, without a MiddlewareProbe around each
+    # middleware and the router, so the span tree starts at the controller
+    # action; it's read when Rails builds the stack, after the initializers.
+    # With the probes in place, the dashboard's setting of the same name turns
+    # their recording on and off (see #middleware_spans_active?).
+    attr_accessor :middleware_spans_enabled
+
     # Remote-managed settings (overwritten by backend JSON `settings` on successful API responses)
     attr_accessor :memory_tracking_enabled, :allocation_tracking_enabled, :allocation_sample_rate,
       :sample_rate, :slow_query_threshold_ms, :watch_enabled,
@@ -73,7 +81,7 @@ module DeadBro
       explain_enabled slow_query_threshold_ms max_sql_queries_to_send max_logs_to_send
       watch_enabled excluded_controllers excluded_jobs exclusive_controllers exclusive_jobs
       monitor_enabled enable_db_stats enable_process_stats enable_system_stats
-      sample_rates_by_type report_routing_errors
+      sample_rates_by_type report_routing_errors middleware_spans_enabled
     ].freeze
 
     def initialize
@@ -89,6 +97,10 @@ module DeadBro
       @explicit_deploy_revision = nil
       @disk_paths = ["/"]
       @interfaces_ignore = %w[lo lo0 docker0]
+      @middleware_spans_enabled = true
+      # The dashboard's switch for recording middleware spans; on until a
+      # settings response says otherwise (older backends never send it).
+      @remote_middleware_spans_enabled = true
 
       # Remote-managed defaults (used until backend sends real values)
       @sample_rate = 100
@@ -193,6 +205,10 @@ module DeadBro
             # must never be able to switch it on — only off. The local opt-in
             # (explain_enabled) stays untouched; see #explain_active?
             @remote_explain_enabled = !!value
+          when "middleware_spans_enabled"
+            # The probes are already in place (or not) by now; this only turns
+            # their recording on and off. The local value stays as it was.
+            @remote_middleware_spans_enabled = !!value
           when "enabled", "memory_tracking_enabled", "allocation_tracking_enabled", "watch_enabled",
                "monitor_enabled", "enable_db_stats", "enable_process_stats", "enable_system_stats",
                "report_routing_errors"
@@ -212,6 +228,13 @@ module DeadBro
       !!(@explain_enabled && @remote_explain_enabled)
     end
 
+    # Middleware spans are recorded when the app hasn't turned them off in its
+    # initializer (which also leaves the stack without probes) and the
+    # dashboard hasn't either.
+    def middleware_spans_active?
+      !!(@middleware_spans_enabled && @remote_middleware_spans_enabled)
+    end
+
     alias_method :explain_analyze_active?, :explain_active?
 
     def heartbeat_due?

data/lib/dead_bro/elasticsearch_subscriber.rb

@@ -130,7 +130,7 @@ module DeadBro
       end
 
       def build_event(method, path, status, duration_ms, start_offset_ms = nil)
-        {
+        event = {
           method: method.to_s.upcase,
           path: sanitize_path(path),
           operation: extract_operation(method, path),
@@ -138,6 +138,9 @@ module DeadBro
           duration_ms: duration_ms,
           start_offset_ms: start_offset_ms
         }
+        parent_id = DeadBro::SpanTracker.current_id
+        event[:parent_id] = parent_id if parent_id
+        event
       end
     end
   end

data/lib/dead_bro/http_instrumentation.rb

@@ -8,6 +8,10 @@ module DeadBro
     EVENT_NAME = "outgoing.http"
     THREAD_LOCAL_KEY = :dead_bro_http_events
     MAX_TRACKED_EVENTS = 1000
+    # Set while DeadBro's Faraday middleware runs the request: the adapter's
+    # own Net::HTTP or Typhoeus call is that request, recorded once by the
+    # middleware.
+    IN_FARADAY_KEY = :dead_bro_http_in_faraday
 
     def self.install!(client: Client.new)
       install_net_http!(client)
@@ -50,7 +54,11 @@ module DeadBro
               tracking_start = Thread.current[DeadBro::TRACKING_START_TIME_KEY]
               start_offset_ms = tracking_start ? ((wall_start - tracking_start) * 1000.0).round(2) : nil
 
-              if is_es_host
+              if Thread.current[DeadBro::HttpInstrumentation::IN_FARADAY_KEY]
+                # Faraday sent it through this adapter; DeadBro's Faraday
+                # middleware around the request records it.
+                nil
+              elsif is_es_host
                 # Route to elasticsearch subscriber instead of http_outgoing
                 if Thread.current[DeadBro::ElasticsearchSubscriber::THREAD_LOCAL_KEY]
                   path = (uri && uri.path) || req.path
@@ -75,6 +83,8 @@ module DeadBro
                   start_offset_ms: start_offset_ms,
                   exception: error && error.class.name
                 }
+                parent_id = DeadBro::SpanTracker.current_id
+                payload[:parent_id] = parent_id if parent_id
                 if Thread.current[THREAD_LOCAL_KEY] && DeadBro::HttpInstrumentation.should_continue_tracking?
                   Thread.current[THREAD_LOCAL_KEY] << payload
                 end
@@ -106,7 +116,9 @@ module DeadBro
                 (respond_to?(:base_url) ? base_url : nil)
               end
 
-              skip_instrumentation = req_url && (req_url.include?("localhost:3100/apm/v1/metrics") || req_url.include?("deadbro.aberatii.com/apm/v1/metrics"))
+              # Inside DeadBro's Faraday middleware, which records the request.
+              skip_instrumentation = Thread.current[DeadBro::HttpInstrumentation::IN_FARADAY_KEY] ||
+                (req_url && (req_url.include?("localhost:3100/apm/v1/metrics") || req_url.include?("deadbro.aberatii.com/apm/v1/metrics")))
 
               unless skip_instrumentation
                 payload = {
@@ -116,6 +128,8 @@ module DeadBro
                   status: response && response.code,
                   duration_ms: duration_ms
                 }
+                parent_id = DeadBro::SpanTracker.current_id
+                payload[:parent_id] = parent_id if parent_id
                 if Thread.current[THREAD_LOCAL_KEY] && DeadBro::HttpInstrumentation.should_continue_tracking?
                   Thread.current[THREAD_LOCAL_KEY] << payload
                 end
@@ -137,10 +151,21 @@ module DeadBro
         middleware_klass = Class.new(::Faraday::Middleware) do
           def call(env)
             start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+            wall_start = Time.now
             response = nil
+            error = nil
+            # A request this middleware leaves out (below) is left to the
+            # adapter's own Net::HTTP or Typhoeus hook, as before.
+            records = DeadBro::HttpInstrumentation.faraday_records?(env)
+            in_faraday = Thread.current[DeadBro::HttpInstrumentation::IN_FARADAY_KEY]
+            Thread.current[DeadBro::HttpInstrumentation::IN_FARADAY_KEY] = true if records
             begin
               response = @app.call(env)
+            rescue => e
+              error = e
+              raise
             ensure
+              Thread.current[DeadBro::HttpInstrumentation::IN_FARADAY_KEY] = in_faraday
               finish_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
               duration_ms = ((finish_time - start_time) * 1000.0).round(2)
               begin
@@ -150,7 +175,9 @@ module DeadBro
                 url_str = url.to_s
 
                 is_es_host = DeadBro::HttpInstrumentation.elasticsearch_host?(host, port)
-                skip = !is_es_host && (url_str.include?("localhost") || url_str.include?("aberatii.com"))
+
+                tracking_start = Thread.current[DeadBro::TRACKING_START_TIME_KEY]
+                start_offset_ms = tracking_start ? ((wall_start - tracking_start) * 1000.0).round(2) : nil
 
                 if is_es_host
                   if Thread.current[DeadBro::ElasticsearchSubscriber::THREAD_LOCAL_KEY]
@@ -158,10 +185,11 @@ module DeadBro
                       method: env.method.to_s.upcase,
                       path: url.path,
                       status: response&.status,
-                      duration_ms: duration_ms
+                      duration_ms: duration_ms,
+                      start_offset_ms: start_offset_ms
                     )
                   end
-                elsif !skip
+                elsif records
                   lib = DeadBro::HttpInstrumentation.typesense_host?(host, port) ? "typesense" : "faraday"
                   payload = {
                     library: lib,
@@ -170,8 +198,12 @@ module DeadBro
                     host: host,
                     path: url.path,
                     status: response&.status,
-                    duration_ms: duration_ms
+                    duration_ms: duration_ms,
+                    start_offset_ms: start_offset_ms,
+                    exception: error&.class&.name
                   }
+                  parent_id = DeadBro::SpanTracker.current_id
+                  payload[:parent_id] = parent_id if parent_id
                   key = DeadBro::HttpInstrumentation::THREAD_LOCAL_KEY
                   if Thread.current[key] && DeadBro::HttpInstrumentation.should_continue_tracking?
                     Thread.current[key] << payload
@@ -202,6 +234,16 @@ module DeadBro
     rescue
     end
 
+    # Whether DeadBro's Faraday middleware records the request: everything but
+    # localhost and DeadBro's own endpoint, Elasticsearch hosts always.
+    def self.faraday_records?(env)
+      url = env.url
+      url_str = url.to_s
+      elasticsearch_host?(url.host.to_s, url.port) || !(url_str.include?("localhost") || url_str.include?("aberatii.com"))
+    rescue *DeadBro::CONTAINED_ERRORS
+      false
+    end
+
     def self.elasticsearch_host?(host, port)
       return false if host.nil?
       return true if port == 9200

data/lib/dead_bro/job_subscriber.rb

@@ -141,6 +141,8 @@ module DeadBro
           gc_pressure: gc_pressure,
           ar_instantiation_count: ar_instantiation_count,
           status: has_error ? "failed" : "completed",
+          sql_count: DeadBro::Subscriber.sql_count(sql_queries),
+          sql_cached_count: DeadBro::Subscriber.sql_cached_count(sql_queries),
           sql_queries: sql_queries,
           transaction_events: transaction_events,
           rails_env: DeadBro.env,

data/lib/dead_bro/middleware_probe.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+module DeadBro
+  # Times one Rack middleware — or the router the stack ends in — as a span of
+  # the request's tree (see SpanTracker). Rails wraps every middleware in one
+  # when it builds the app's middleware stack; the probe reads a clock on the
+  # way in and out and allocates nothing.
+  class MiddlewareProbe
+    attr_reader :span_name, :span_kind
+
+    def initialize(app, name, kind)
+      @app = app
+      @span_name = name
+      @span_kind = kind
+    end
+
+    def call(env)
+      frame = SpanTracker.rack_enter(self)
+      @app.call(env)
+    ensure
+      SpanTracker.rack_leave(frame) if frame
+    end
+
+    # Anything else asked of the middleware goes to it unchanged.
+    def respond_to_missing?(method_name, include_private = false)
+      @app.respond_to?(method_name, include_private) || super
+    end
+
+    def method_missing(method_name, *args, &block)
+      if @app.respond_to?(method_name)
+        @app.public_send(method_name, *args, &block)
+      else
+        super
+      end
+    end
+    ruby2_keywords(:method_missing) if respond_to?(:ruby2_keywords, true)
+
+    # ActionDispatch::MiddlewareStack::Middleware#build: one probe per middleware.
+    module MiddlewareBuild
+      def build(app)
+        return super unless MiddlewareProbe.enabled?
+
+        MiddlewareProbe.wrap(super, inspect, SpanTracker::MIDDLEWARE)
+      end
+    end
+
+    # ActionDispatch::MiddlewareStack#build: a probe around the endpoint (the
+    # app's routes), so routing and controller setup aren't counted as the
+    # innermost middleware's own time.
+    module StackBuild
+      def build(app = nil, &block)
+        endpoint = app || block
+        return super if endpoint.nil? || !MiddlewareProbe.enabled?
+
+        super(MiddlewareProbe.wrap(endpoint, endpoint.class.name, SpanTracker::ENDPOINT))
+      end
+    end
+
+    # config.middleware_spans_enabled, read when Rails builds the stack.
+    def self.enabled?
+      DeadBro.configuration.middleware_spans_enabled ? true : false
+    rescue
+      true
+    end
+
+    def self.wrap(app, name, kind)
+      new(app, name.to_s.dup.freeze, kind)
+    rescue
+      app
+    end
+
+    # Must run before Rails builds the middleware stack (the
+    # build_middleware_stack initializer); a stack built earlier has no probes.
+    def self.install!
+      return false unless defined?(::ActionDispatch::MiddlewareStack)
+
+      stack = ::ActionDispatch::MiddlewareStack
+      stack.prepend(StackBuild) unless stack.ancestors.include?(StackBuild)
+      stack::Middleware.prepend(MiddlewareBuild) unless stack::Middleware.ancestors.include?(MiddlewareBuild)
+      true
+    rescue
+      false
+    end
+  end
+end

data/lib/dead_bro/railtie.rb

@@ -53,6 +53,11 @@ if defined?(Rails) && defined?(Rails::Railtie)
           require "dead_bro/view_rendering_subscriber"
           DeadBro::ViewRenderingSubscriber.subscribe!(client: shared_client)
 
+          # Install the span tree (controller action and view spans; the
+          # middleware spans come from the probes installed below)
+          require "dead_bro/span_tracker"
+          DeadBro::SpanTracker.subscribe!
+
           # Install lightweight memory tracking (default)
           require "dead_bro/lightweight_memory_tracker"
           require "dead_bro/memory_leak_detector"
@@ -104,6 +109,17 @@ if defined?(Rails) && defined?(Rails::Railtie)
         # Never raise in Railtie init
       end
 
+      # Time every middleware and the router for the span tree. Railtie
+      # initializers run before the application's build_middleware_stack, so
+      # the probes are in place when Rails builds the stack.
+      initializer "dead_bro.middleware_probes" do
+        require "dead_bro/span_tracker"
+        require "dead_bro/middleware_probe"
+        DeadBro::MiddlewareProbe.install!
+      rescue
+        # Never raise in Railtie init
+      end
+
       # Insert SQL tracking middleware
       initializer "dead_bro.sql_tracking_middleware" do |app|
         require "dead_bro/sql_tracking_middleware"

data/lib/dead_bro/redis_subscriber.rb

@@ -90,6 +90,8 @@ module DeadBro
                 db: RedisSubscriber.safe_db(@db),
                 error: error ? error.class.name : nil
               }
+              parent_id = DeadBro::SpanTracker.current_id
+              event[:parent_id] = parent_id if parent_id
 
               if Thread.current[RedisSubscriber::THREAD_LOCAL_KEY] && RedisSubscriber.should_continue_tracking?
                 Thread.current[RedisSubscriber::THREAD_LOCAL_KEY] << event
@@ -122,6 +124,8 @@ module DeadBro
                 start_offset_ms: start_offset_ms,
                 db: RedisSubscriber.safe_db(@db)
               }
+              parent_id = DeadBro::SpanTracker.current_id
+              event[:parent_id] = parent_id if parent_id
 
               if Thread.current[RedisSubscriber::THREAD_LOCAL_KEY] && RedisSubscriber.should_continue_tracking?
                 Thread.current[RedisSubscriber::THREAD_LOCAL_KEY] << event
@@ -154,6 +158,8 @@ module DeadBro
                 start_offset_ms: start_offset_ms,
                 db: RedisSubscriber.safe_db(@db)
               }
+              parent_id = DeadBro::SpanTracker.current_id
+              event[:parent_id] = parent_id if parent_id
 
               if Thread.current[RedisSubscriber::THREAD_LOCAL_KEY] && RedisSubscriber.should_continue_tracking?
                 Thread.current[RedisSubscriber::THREAD_LOCAL_KEY] << event
@@ -220,7 +226,7 @@ module DeadBro
 
     def self.build_event(name, data, duration_ms, start_offset_ms = nil)
       cmd = extract_command(data)
-      {
+      event = {
         event: name.to_s,
         command: cmd[:command],
         key: cmd[:key],
@@ -229,6 +235,9 @@ module DeadBro
         start_offset_ms: start_offset_ms,
         db: safe_db(data[:db])
       }
+      parent_id = DeadBro::SpanTracker.current_id
+      event[:parent_id] = parent_id if parent_id
+      event
     rescue
       nil
     end