dead_bro 0.2.35 → 0.2.37

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2544ca10e878c96153137ba46f40a543e157eff3c877b1bd3211eec15b01a9e7
-  data.tar.gz: 046c6f63e058e9273e8f978f42a727164c4e366c65111169c1a3d86b29ebae43
+  metadata.gz: 85f75545759422dfd14db796ac17035d9d6722e8e68e9c31e9ef0382358e93f8
+  data.tar.gz: beed782f1043421e364b1548db3dcd29dd1389d54d46440c2ff65aaf81a4b6af
 SHA512:
-  metadata.gz: badda478e44e521b88d558413370bde506ecb7693c5a77864fc9953f9a082a97722c5c942386e16c8eeb3a15488e196d96da799a494ff9e9ee87cd304ea437bc
-  data.tar.gz: 18f19c4e1dc982cb7e6ec422a11ff4e443f1759b73e9841757987c4d8e9b5b3c914dc6995c65cbccf0bdd48110e3214e357b62546585558a3e6cab7ee2de83a1
+  metadata.gz: 1dd65b6b589c013f24d18a548491aa6203c990cf0522c23c0e9000939898aed0e6927a26793c1a8eb80e4fe96e7a9c72176436f2cf8d3ae84848562b2fb82c2d
+  data.tar.gz: c0c020935c96898d9c54bd1b9f39ee77bf7040b8ad0cf2a9d51487af14199dca91b46e6b89b66e99c73cce470452136cb71d49ae2535f725b05edcd8b1511bdc

data/CHANGELOG.md

@@ -1,5 +1,22 @@
 ## [Unreleased]
 
+## [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.
+
+### Fixed
+- **The in-process leak detector's `object_count` was always 0.** `gc_stats` never read `heap_live_slots`, so every `MemoryLeakDetector` sample recorded `object_count: 0` and the `object_stats` / `memory_efficiency` figures from `DeadBro::MemoryHelpers.analyze_memory` were meaningless. `gc_stats` now includes `heap_live_slots` — in request and job payloads alike — and the request's leak sample and payload share one `GC.stat` read. `average_memory_per_object_kb` is now actually in KB; it divided RSS in MB by the object count.
+
 ## [0.2.35] - 2026-10-21
 
 ### Fixed

data/lib/dead_bro/gc_tracker.rb

@@ -29,14 +29,17 @@ module DeadBro
       # Memory-tracking enrichment (a few extra GC.stat reads). Only the base
       # GC pressure fields above are truly always-on.
       if memory_tracking_enabled?
-        # Live heap slots — net retained objects. Comparing this delta against
-        # allocated_objects separates transient churn from genuine retention.
+        # Live heap slots, process-wide. How to read their delta is explained
+        # in self.diff below.
         base[:heap_live_slots] = stat[:heap_live_slots] || 0
         # Bytes malloc'd outside the Ruby object heap (big strings/buffers, e.g.
         # parsed JSON response bodies). These are point-in-time gauges reset by
         # GC, so we report the request-end value rather than a diff.
         base[:malloc_increase_bytes] = stat[:malloc_increase_bytes] || 0
         base[:oldmalloc_increase_bytes] = stat[:oldmalloc_increase_bytes] || 0
+        # The GC's phase right after those counters were read: :none, :marking
+        # or :sweeping. See self.diff below.
+        base[:gc_state] = gc_state
       end
 
       base
@@ -44,6 +47,13 @@ module DeadBro
       {}
     end
 
+    # A single-key read: no hash is built. nil where the VM doesn't report it.
+    def self.gc_state
+      GC.latest_gc_info(:state) if GC.respond_to?(:latest_gc_info)
+    rescue
+      nil
+    end
+
     def self.diff(before, after)
       return {} if before.empty? || after.empty?
       gc_time_ms = if before[:gc_time_ns] && after[:gc_time_ns]
@@ -58,10 +68,19 @@ module DeadBro
 
       # Present only when the enrichment was captured (memory tracking enabled).
       if after.key?(:heap_live_slots) || before.key?(:heap_live_slots)
-        # Net change in live slots over the request. A small value alongside a
-        # large allocated_objects means the memory was transient (reclaimed by
-        # GC); a large value means objects were retained — the real leak signal.
+        # Signed net change in live slots over the request. Like allocated_objects
+        # it is process-wide: every thread's allocations and frees count. It only
+        # separates transient churn from retention once a GC in the window has
+        # finished: without one, slots are freed only by the lazy sweep of an
+        # earlier GC, and a GC still running when the window closes hasn't freed
+        # all its garbage yet. It goes negative when more is freed than
+        # allocated. Read it together with minor_gc_runs/major_gc_runs and
+        # gc_state_at_end.
         result[:heap_live_slots_growth] = (after[:heap_live_slots] || 0) - (before[:heap_live_slots] || 0)
+        # The GC's phase when the window closed: "none" once the last GC has
+        # finished, "marking" or "sweeping" while it's still running (Ruby marks
+        # and sweeps in steps between allocations).
+        result[:gc_state_at_end] = after[:gc_state].to_s if after[:gc_state]
         # Off-heap malloc pressure pending at request end (see snapshot).
         result[:malloc_increase_bytes] = after[:malloc_increase_bytes] || 0
         result[:oldmalloc_increase_bytes] = after[:oldmalloc_increase_bytes] || 0

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,
@@ -307,6 +309,7 @@ module DeadBro
           count: stats[:count] || 0,
           heap_allocated_pages: stats[:heap_allocated_pages] || 0,
           heap_sorted_pages: stats[:heap_sorted_pages] || 0,
+          heap_live_slots: stats[:heap_live_slots] || 0,
           total_allocated_objects: stats[:total_allocated_objects] || 0
         }
       else

data/lib/dead_bro/memory_leak_detector.rb

@@ -141,8 +141,9 @@ module DeadBro
       def calculate_memory_efficiency(samples)
         return {} if samples.length < 2
 
+        # memory_usage is RSS in MB; object_count is live heap slots.
         memory_per_object = samples.map do |sample|
-          (sample[:object_count] > 0) ? sample[:memory_usage] / sample[:object_count] : 0
+          (sample[:object_count] > 0) ? sample[:memory_usage] * 1024.0 / sample[:object_count] : 0
         end
 
         gc_efficiency = []

data/lib/dead_bro/subscriber.rb

@@ -139,13 +139,16 @@ module DeadBro
           }
         end
 
+        # One GC.stat read for both the leak-detection sample and the payload.
+        end_gc_stats = gc_stats
+
         # Record memory sample for leak detection (only if memory tracking enabled)
         if DeadBro.configuration.memory_tracking_enabled
           DeadBro::MemoryLeakDetector.record_memory_sample({
             memory_usage: memory_usage_mb,
-            gc_count: gc_stats[:count],
-            heap_pages: gc_stats[:heap_allocated_pages],
-            object_count: gc_stats[:heap_live_slots],
+            gc_count: end_gc_stats[:count],
+            heap_pages: end_gc_stats[:heap_allocated_pages],
+            object_count: end_gc_stats[:heap_live_slots],
             request_id: data[:request_id],
             controller: data[:controller],
             action: data[:action]
@@ -162,8 +165,9 @@ module DeadBro
           view_runtime_ms: data[:view_runtime],
           db_runtime_ms: data[:db_runtime],
           memory_usage: memory_usage_mb,
-          gc_stats: gc_stats,
-          sql_count: sql_count(data),
+          gc_stats: end_gc_stats,
+          sql_count: sql_count(sql_queries),
+          sql_cached_count: sql_cached_count(sql_queries),
           sql_queries: sql_queries,
           transaction_events: transaction_events,
           http_outgoing: Thread.current[:dead_bro_http_events] || [],
@@ -459,6 +463,7 @@ module DeadBro
           count: stats[:count] || 0,
           heap_allocated_pages: stats[:heap_allocated_pages] || 0,
           heap_sorted_pages: stats[:heap_sorted_pages] || 0,
+          heap_live_slots: stats[:heap_live_slots] || 0,
           total_allocated_objects: stats[:total_allocated_objects] || 0
         }
       else
@@ -468,20 +473,24 @@ module DeadBro
       {}
     end
 
-    def self.sql_count(data)
-      # Count SQL queries from the payload if available
-      if data[:sql_count]
-        data[:sql_count]
-      elsif defined?(ActiveRecord) && ActiveRecord::Base.connection
-        # Try to get from ActiveRecord connection
-        begin
-          ActiveRecord::Base.connection.query_cache.size
-        rescue
-          0
-        end
-      else
-        0
-      end
+    # Number of SQL statements run during the request, query-cache hits included
+    # (the same count as Rails' "ActiveRecord: …ms (N queries, M cached)" log
+    # line). Summed from SqlSubscriber.stop_request_tracking's per-statement
+    # aggregates, which count every query — the raw query list stops at
+    # MAX_TRACKED_QUERIES. This used to read
+    # ActiveRecord::Base.connection.query_cache.size: the number of distinct
+    # cached SELECTs, an LRU capped at 100 since Rails 7.1, so every N+1 page
+    # reported "100" — and it leased a DB connection on requests with no SQL.
+    def self.sql_count(sql_queries)
+      Array(sql_queries).sum { |agg| agg[:count].to_i }
+    rescue
+      0
+    end
+
+    # How many of sql_count were answered by the query cache, sent separately so
+    # the dashboard can tell repeated cache hits from database round trips.
+    def self.sql_cached_count(sql_queries)
+      Array(sql_queries).sum { |agg| agg[:cached_count].to_i }
     rescue
       0
     end

data/lib/dead_bro/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module DeadBro
-  VERSION = "0.2.35"
+  VERSION = "0.2.37"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: dead_bro
 version: !ruby/object:Gem::Version
-  version: 0.2.35
+  version: 0.2.37
 platform: ruby
 authors:
 - Emanuel Comsa