dead_bro 0.2.34 → 0.2.35

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1e87bf1af27a0f9c5e26679757060bbef1d1a84e3a9ff597e997ee6665041f06
-  data.tar.gz: 9872d696d014494ed15f7ac83e809530a1d4f54f5d5db23d783e8c6af99f2fd2
+  metadata.gz: 2544ca10e878c96153137ba46f40a543e157eff3c877b1bd3211eec15b01a9e7
+  data.tar.gz: 046c6f63e058e9273e8f978f42a727164c4e366c65111169c1a3d86b29ebae43
 SHA512:
-  metadata.gz: ae026a67741f9561d7b2423cd9c35a6bd80b3c1b1b0365279b665caea0cd2d45f5e7519bae715890114458be8dbe284bab766a7437a41f8c841557fbfbb00ee2
-  data.tar.gz: 87c6441aa1789ca958c5980edadef4d5e1d5a73e03573d8684a02dbb62c26a31f8ae13300487901b63e4ba1fcca62fc4ba0676badd059d44783613dc21fb09af
+  metadata.gz: badda478e44e521b88d558413370bde506ecb7693c5a77864fc9953f9a082a97722c5c942386e16c8eeb3a15488e196d96da799a494ff9e9ee87cd304ea437bc
+  data.tar.gz: 18f19c4e1dc982cb7e6ec422a11ff4e443f1759b73e9841757987c4d8e9b5b3c914dc6995c65cbccf0bdd48110e3214e357b62546585558a3e6cab7ee2de83a1

data/CHANGELOG.md

@@ -1,5 +1,14 @@
 ## [Unreleased]
 
+## [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/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
@@ -279,6 +283,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)

data/lib/dead_bro/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module DeadBro
-  VERSION = "0.2.34"
+  VERSION = "0.2.35"
 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.35
 platform: ruby
 authors:
 - Emanuel Comsa