dead_bro 0.2.34 → 0.2.36

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1e87bf1af27a0f9c5e26679757060bbef1d1a84e3a9ff597e997ee6665041f06
-  data.tar.gz: 9872d696d014494ed15f7ac83e809530a1d4f54f5d5db23d783e8c6af99f2fd2
+  metadata.gz: 7f33da7799522248140cc65b3637ae2a1dede4295b3696370bd3aabea0d09c7b
+  data.tar.gz: 376071ecd3eafe0e41695246074ccea3b3a2c479532d08eb24d46fa0d471c94e
 SHA512:
-  metadata.gz: ae026a67741f9561d7b2423cd9c35a6bd80b3c1b1b0365279b665caea0cd2d45f5e7519bae715890114458be8dbe284bab766a7437a41f8c841557fbfbb00ee2
-  data.tar.gz: 87c6441aa1789ca958c5980edadef4d5e1d5a73e03573d8684a02dbb62c26a31f8ae13300487901b63e4ba1fcca62fc4ba0676badd059d44783613dc21fb09af
+  metadata.gz: ba9539bb294999bcd1d3b1f4bed9bc7612d4b9f3e66fe92769de92a0b50d8991ffadf2daf6e418b3951fcda7b8e1ae9afa5b6980c4de7af49d982ccd07aff6f2
+  data.tar.gz: 1e9abbd0ef17016ea6f639fa60d6d18edc0b481cdeec3d6495f52f5ae31e73a413db0bb7e7607b274a344d8ab1b33dda098dca608c617a024622aff3796fc8e0

data/CHANGELOG.md

@@ -1,5 +1,20 @@
 ## [Unreleased]
 
+### 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
+- **In production, every exception raised in a controller action was sent to DeadBro twice.** The request subscriber reports it with the request's details; the exception then reached `ErrorMiddleware` on its way out (with `consider_all_requests_local` off, `ActionDispatch::DebugExceptions` re-raises it instead of rendering the debug page), which sent it again. The dashboard already counted each error once, so the second request was wasted work for the app. The subscriber now flags the request in the Rack env (`env["dead_bro.reported"]`) and `ErrorMiddleware` skips flagged requests, so one error is one request to DeadBro. `ErrorMiddleware` still reports exceptions that never reach a controller action. An exception raised in an excluded controller is no longer sent at all.
+
+### Changed
+- **Requests that match no route are no longer sent unless the app's settings ask for them.** Rails raises `ActionController::RoutingError` for them in the middleware stack, not in a controller, and `ErrorMiddleware` sent each one to DeadBro, which discarded it. Turn on "Track requests that match no route" in the app's settings in DeadBro (the `report_routing_errors` setting) to have them sent and stored as `ActionController::RoutingError` errors. A `RoutingError` raised by a controller action is still reported, once, by the request subscriber.
+- `ErrorMiddleware` reports now carry the response status, the time the request took, the machine's host name and the request's host, so DeadBro can store them as requests.
+
 ## [0.2.34] - 2026-09-29
 
 ### Fixed

data/README.md

@@ -61,6 +61,8 @@ For **Amazon ECS**, add one of these variables in your task definition from Code
 
 Use the DeadBro UI to turn features on or off, set sample rates, define controller/job inclusions and exclusions, tune slow-query EXPLAIN, enable queue and system metrics, and adjust related limits. After you deploy the initializer above, those choices take effect when the gem receives them from the API (typically on the next successful metric or heartbeat response).
 
+Requests that match none of the app's routes (`ActionController::RoutingError`) aren't sent unless "Track requests that match no route" is on in the app's settings (`report_routing_errors`, off by default). DeadBro then stores them as `ActionController::RoutingError` errors.
+
 ### Optional local flags
 
 You can still set `config.enabled` in Ruby if you need to force the integration off in a given environment before any remote settings arrive; otherwise the dashboard can control `enabled` like other remote settings.

data/lib/dead_bro/configuration.rb

@@ -23,7 +23,7 @@ module DeadBro
     attr_accessor :memory_tracking_enabled, :allocation_tracking_enabled, :allocation_sample_rate,
       :sample_rate, :slow_query_threshold_ms, :watch_enabled,
       :monitor_enabled, :enable_db_stats, :enable_process_stats, :enable_system_stats,
-      :max_sql_queries_to_send, :max_logs_to_send
+      :max_sql_queries_to_send, :max_logs_to_send, :report_routing_errors
 
     # Readers for exclusion lists. Writers are defined below so we can compile
     # and cache the regex form once, instead of rebuilding it per request.
@@ -73,7 +73,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
+      sample_rates_by_type report_routing_errors
     ].freeze
 
     def initialize
@@ -116,6 +116,10 @@ module DeadBro
       @enable_db_stats = false
       @enable_process_stats = false
       @enable_system_stats = false
+      # A request that matches no route raises ActionController::RoutingError in
+      # the middleware stack, not in a controller. ErrorMiddleware sends those
+      # only when this is on.
+      @report_routing_errors = false
 
       @settings_received_at = nil
       @skip_until = nil
@@ -190,7 +194,8 @@ module DeadBro
             # (explain_enabled) stays untouched; see #explain_active?
             @remote_explain_enabled = !!value
           when "enabled", "memory_tracking_enabled", "allocation_tracking_enabled", "watch_enabled",
-               "monitor_enabled", "enable_db_stats", "enable_process_stats", "enable_system_stats"
+               "monitor_enabled", "enable_db_stats", "enable_process_stats", "enable_system_stats",
+               "report_routing_errors"
             send(:"#{k}=", !!value)
           when "excluded_controllers", "excluded_jobs", "exclusive_controllers", "exclusive_jobs"
             send(:"#{k}=", Array(value).map(&:to_s))

data/lib/dead_bro/error_middleware.rb

@@ -12,14 +12,17 @@ module DeadBro
     end
 
     def call(env)
+      started = Process.clock_gettime(Process::CLOCK_MONOTONIC)
       @app.call(env)
     rescue Exception => exception # rubocop:disable Lint/RescueException
       begin
-        payload = build_payload(exception, env)
-        # Use the error class name as the event name
-        event_name = exception.class.name.to_s
-        event_name = EVENT_NAME if event_name.empty?
-        @client.post_metric(event_name: event_name, payload: payload, force: true)
+        if report?(exception, env)
+          payload = build_payload(exception, env, started)
+          # Use the error class name as the event name
+          event_name = exception.class.name.to_s
+          event_name = EVENT_NAME if event_name.empty?
+          @client.post_metric(event_name: event_name, payload: payload, force: true)
+        end
       rescue *DeadBro::CONTAINED_ERRORS
         # Never let APM reporting interfere with the host app — in particular,
         # never replace the host's exception with one of ours.
@@ -29,7 +32,23 @@ module DeadBro
 
     private
 
-    def build_payload(exception, env)
+    # Only exceptions that never reached a controller action are this
+    # middleware's: the request subscriber reports the others, with the
+    # request's details, and flags the env. A request that matches no route
+    # raises ActionController::RoutingError here; those are sent only when the
+    # app's report_routing_errors setting is on.
+    def report?(exception, env)
+      return false if env[DeadBro::Subscriber::REPORTED_ENV_KEY]
+      return !!DeadBro.configuration.report_routing_errors if routing_error?(exception)
+
+      true
+    end
+
+    def routing_error?(exception)
+      defined?(::ActionController::RoutingError) && exception.is_a?(::ActionController::RoutingError)
+    end
+
+    def build_payload(exception, env, started)
       req = rack_request(env)
 
       payload = {
@@ -39,6 +58,11 @@ module DeadBro
         fingerprint: DeadBro::Subscriber.compute_error_fingerprint(exception),
         cause_chain: DeadBro::Subscriber.build_cause_chain(exception),
         occurred_at: Time.now.utc.to_i,
+        # What the backend needs to store the report as a request.
+        status: response_status(exception),
+        duration_ms: elapsed_ms(started),
+        host: DeadBro.safe_hostname,
+        request_host: DeadBro::Subscriber.safe_request_host({env: env}),
         rack:
           {
             method: req&.request_method,
@@ -69,6 +93,22 @@ module DeadBro
       nil
     end
 
+    # The status Rails answers the exception with: 404 for a RoutingError, else
+    # 500 unless the app maps the class elsewhere (action_dispatch.rescue_responses).
+    def response_status(exception)
+      return 500 unless defined?(::ActionDispatch::ExceptionWrapper)
+
+      ::ActionDispatch::ExceptionWrapper.status_code_for_exception(exception.class.name)
+    rescue
+      500
+    end
+
+    def elapsed_ms(started)
+      ((Process.clock_gettime(Process::CLOCK_MONOTONIC) - started) * 1000.0).round(2)
+    rescue
+      nil
+    end
+
     def safe_backtrace(exception)
       Array(exception.backtrace).first(50)
     rescue

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

@@ -307,6 +307,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

@@ -9,6 +9,10 @@ module DeadBro
 
     def self.subscribe!(client: Client.new)
       ActiveSupport::Notifications.subscribe(EVENT_NAME) do |name, started, finished, _unique_id, data|
+        # An exception the action raised is this listener's to report (or to
+        # drop with an excluded request) — ErrorMiddleware must not send it again.
+        mark_reported(data)
+
         # When disabled remotely, fire a heartbeat at most once per minute so the gem
         # can detect when tracking has been re-enabled, then skip all tracking.
         unless DeadBro.configuration.enabled
@@ -135,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]
@@ -158,7 +165,7 @@ module DeadBro
           view_runtime_ms: data[:view_runtime],
           db_runtime_ms: data[:db_runtime],
           memory_usage: memory_usage_mb,
-          gc_stats: gc_stats,
+          gc_stats: end_gc_stats,
           sql_count: sql_count(data),
           sql_queries: sql_queries,
           transaction_events: transaction_events,
@@ -279,6 +286,23 @@ module DeadBro
       # Best effort — draining must never raise from the notifications callback.
     end
 
+    # Set in the Rack env when the controller action raised. The exception then
+    # passes ErrorMiddleware on its way out (in production DebugExceptions
+    # re-raises it), which skips flagged requests so one error is one POST.
+    REPORTED_ENV_KEY = "dead_bro.reported"
+
+    def self.mark_reported(data)
+      return unless data[:exception] || data[:exception_object]
+
+      # The payload carries the request since Rails 6.1. Not data[:headers]:
+      # ActionDispatch::Http::Headers#env is a copy, the flag would be lost.
+      request = data[:request]
+      env = request.env if request.respond_to?(:env)
+      env[REPORTED_ENV_KEY] = true if env.is_a?(Hash)
+    rescue
+      # Best effort — without the flag ErrorMiddleware reports the exception too.
+    end
+
     def self.safe_path(data)
       path = data[:path] || (data[:request] && data[:request].path)
       sanitize_string(path)
@@ -438,6 +462,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/version.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
 module DeadBro
-  VERSION = "0.2.34"
+  VERSION = "0.2.36"
 end
+

metadata

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