dead_bro 0.2.19 → 0.2.21

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: edddcaa5684cac479f815b4d8e1a377e30f039c6ba910daa6f30b2322538c64c
-  data.tar.gz: 4841c2bcadcd841a61dafc79216e3324fa87a239dea2be7d3cce038934ba28cb
+  metadata.gz: 96a0bc8cf707ea8af5d3bcd0be76fa02e28d09031c8a7897a311754cda8f7440
+  data.tar.gz: 4a1407455415636db2858a28f0f77a8bb530d45fa916a359f85ae22f5f4294bb
 SHA512:
-  metadata.gz: 2dd9071e6620fad08ee1e700ac48199f1b3b62119e68a3d52b2b381eba6152e3a311d28bc64aeb81855a5adb9edacab73decc8ce4c71243eb71f8680cdd41cc1
-  data.tar.gz: 4a1319b9b8f32b56f24a76e4681b7c55fa7b299258b590bffee686fc82ee7d8ad642df890593bf6c62e049225d9dcfc364877fe2ebc20dd6db1262836e9fc1ac
+  metadata.gz: 493d8d79e5eedd0d0443ddc3922ace02ed2f606220e7cff07e07484c9a628a85b54a5160551cb816630e06db34886e22ebae5c6c95e3697784b67a8c71b5b1ad
+  data.tar.gz: 715064a097fadfb5ef97b96be9086f760f91efa004d3d339978f87ab87b6dce935ba5111c60c92a9f1849ec5a17a80e83efbd9f9cab031a963392f03a1055b2e

data/CHANGELOG.md

@@ -1,5 +1,41 @@
 ## [Unreleased]
 
+### Added
+- Monitor thread now sends a synchronous heartbeat on startup before the first collection tick. This ensures remote settings — including `monitor_enabled` — are applied from the very first reporting cycle, so Sidekiq workers and other non-web processes that have not yet sent any metrics still receive the correct configuration immediately on boot rather than waiting up to 60 seconds for the first scheduled tick.
+
+## [0.2.21] - 2026-06-02
+
+### Added
+- **Per-span timing for the Request Trace view.** Every instrumented event now includes a `start_offset_ms` field — the wall-clock milliseconds from rack entry to when that event started. This powers the waterfall visualisation in the DeadBro dashboard without any configuration changes.
+  - `SqlSubscriber`: `start_offset_ms` is computed from `TRACKING_START_TIME_KEY` using the `started` timestamp provided by `ActiveSupport::Notifications`. Stored on both the raw per-query hash and on the first-occurrence aggregate entry (so the bar is positioned at the actual time the query first ran, not a fabricated cumulative offset).
+  - `ViewRenderingSubscriber`: same pattern applied to template, partial, and collection render events. `start_offset_ms` is captured for the first render of each unique identifier and stored on the aggregate.
+  - `CacheSubscriber`: `start_offset_ms` derived from the `started` `ActiveSupport::Notifications` timestamp, added to every cache event hash and passed through `build_event`.
+  - `RedisSubscriber`: `wall_start = Time.now` is captured at the entry point of each instrumented block (`call`, `call_pipeline`, `call_multi`). The monotonic clock is still used for duration accuracy; `wall_start` is used only for the offset relative to `TRACKING_START_TIME_KEY`. Also applied to the `ActiveSupport::Notifications` fallback path in `install_notifications_subscription!`.
+  - `ElasticsearchSubscriber`: `start_offset_ms` added to `build_event`; the `record` method (called from `HttpInstrumentation` for Net::HTTP-based ES requests) now accepts a `start_offset_ms:` keyword argument. The `ActiveSupport::Notifications` subscription path (`request.elasticsearch` / `request.elastic_transport`) computes it from `started`.
+  - `HttpInstrumentation`: `wall_start = Time.now` captured alongside the existing monotonic `start_time`. `start_offset_ms` is included in the HTTP outgoing payload and forwarded to `ElasticsearchSubscriber.record` for requests routed to an ES host.
+
+## [0.2.20] - 2026-05-29
+
+### Added
+- Monitor thread sends a synchronous heartbeat immediately on startup (before the first scheduled collection tick) so that remote settings — including `monitor_enabled` — are applied from the very first reporting cycle. Sidekiq workers and other non-web processes now receive the correct configuration on boot rather than waiting up to 60 seconds for the first tick.
+- `gem_version` field added to every heartbeat payload so the dashboard can display and compare the running gem version per application.
+- `process_kind` included in all system monitor payloads, linking server metrics to the correct process type.
+- `post_heartbeat` now accepts a `sync: true` keyword for situations that require a blocking network call before proceeding (used by the monitor startup path).
+
+## [0.2.19] - 2026-05-28
+
+### Added
+- **Error fingerprinting**: every unhandled exception payload now includes a stable `fingerprint` string derived from the exception class, a normalised version of the message (numeric IDs and UUIDs stripped), and the top application stack frame. Identical errors that differ only in record IDs or UUIDs produce the same fingerprint, enabling reliable grouping and deduplication on the server.
+- `DeadBro.process_kind` auto-detects the type of the current Ruby process by inspecting `$PROGRAM_NAME` and `/proc/self/cmdline`: returns `"web"` (Puma/Passenger/Unicorn/Falcon), `"worker"` (Sidekiq/GoodJob/SolidQueue/DelayedJob), `"console"`, `"task"`, or `"app"` as a fallback. The value is memoised after the first call.
+- `process_kind` included in error event payloads so the backend knows whether an exception came from a web request or a background worker.
+
+## [0.2.18] - 2026-05-27
+
+### Added
+- **N+1 detection in the gem**: SQL queries are normalised (bind parameters, numeric literals, and `IN (...)` lists replaced with `?`) and counted per request. When the same normalised query fires 5 or more times, it is flagged as `n_plus_one: true` on its aggregate entry. A backtrace is captured exactly at the N+1 threshold rather than on every execution, keeping overhead low while still pointing to the callsite.
+- **SQL aggregation**: instead of shipping a raw array of every query, the gem now groups queries by normalised SQL and sends one aggregate entry per unique pattern with `count`, `total_duration_ms`, `min_duration_ms`, `max_duration_ms`, `total_allocations`, and `cached_count`. This reduces payload size on N+1-heavy requests and makes the SQL breakdown directly usable without server-side grouping.
+- **View rendering aggregation**: template, partial, and collection renders are aggregated per identifier (last three path segments). Each entry carries `count`, `total_duration_ms`, `min_duration_ms`, `max_duration_ms`, `rendered_at_min/max`, and cache hit counts. Aggregation happens on the thread-local stack so there is no GC pressure from intermediate arrays.
+
 ## [0.2.17] - 2026-05-25
 
 ### Added
@@ -10,6 +46,12 @@
 ### Added
 - `ArObjectTracker`: subscribes to Rails' built-in `instantiation.active_record` notification to count the total number of ActiveRecord model instances hydrated during each request or background job. The count is reported as `ar_instantiation_count` in every payload. Uses a thread-local counter with an idempotent `subscribe!` guard, matching the same start/stop lifecycle as `GcTracker`. No monkey-patching required — Rails emits this event natively with a `record_count` field that accumulates correctly across batch loads.
 
+## [0.2.15] - 2026-05-24
+
+### Added
+- **`GcTracker`**: records a GC snapshot at the start and end of every request and background job. Reports `gc_minor_runs`, `gc_major_runs`, `gc_allocated_objects`, `gc_time_ms`, and `heap_pages_increase` as a `gc_pressure` hash in every payload. Uses `GC.stat` and `GC::Profiler` with an idempotent subscribe guard; overhead is negligible when no GC cycles occur.
+- **`SqlAllocListener`**: measures GC allocation deltas per SQL event by snapshotting `GC.stat[:total_allocated_objects]` in the notification `start` callback and diffing in `finish`. The delta is stored by notification ID and merged into the corresponding query's `allocations` field, allowing the dashboard to surface allocation-heavy queries independently of their duration.
+
 ## [0.2.14] - 2026-05-23
 
 ### Added

data/lib/dead_bro/cache_subscriber.rb

@@ -24,7 +24,9 @@ module DeadBro
           next unless Thread.current[THREAD_LOCAL_KEY]
 
           duration_ms = ((finished - started) * 1000.0).round(2)
-          event = build_event(name, data, duration_ms)
+          tracking_start = Thread.current[DeadBro::TRACKING_START_TIME_KEY]
+          start_offset_ms = tracking_start ? ((started - tracking_start) * 1000.0).round(2) : nil
+          event = build_event(name, data, duration_ms, start_offset_ms)
           if event && should_continue_tracking?
             Thread.current[THREAD_LOCAL_KEY] << event
           end
@@ -63,12 +65,13 @@ module DeadBro
       true
     end
 
-    def self.build_event(name, data, duration_ms)
+    def self.build_event(name, data, duration_ms, start_offset_ms = nil)
       return nil unless data.is_a?(Hash)
 
       {
         event: name,
         duration_ms: duration_ms,
+        start_offset_ms: start_offset_ms,
         key: safe_key(data[:key]),
         keys_count: safe_keys_count(data[:keys]),
         hit: infer_hit(name, data),

data/lib/dead_bro/client.rb

@@ -32,18 +32,33 @@ module DeadBro
       nil
     end
 
-    def post_heartbeat
+    def post_heartbeat(sync: false)
       return if @configuration.api_key.nil?
 
       @configuration.last_heartbeat_attempt_at = Time.now.utc
-      body = {event: "heartbeat", payload: {}, sent_at: Time.now.utc.iso8601, revision: @configuration.resolve_deploy_id, gem_version: DeadBro::VERSION}
-
-      dispatch_request(
-        url: metrics_endpoint_url,
-        body: body,
-        event_name: "heartbeat",
-        apply_settings: true
-      )
+      body = {event: "heartbeat", payload: {rails_env: DeadBro.env}, sent_at: Time.now.utc.iso8601, revision: @configuration.resolve_deploy_id, gem_version: DeadBro::VERSION}
+
+      if sync
+        # Called from the monitor thread on startup — run inline so settings are
+        # applied before the first collection tick.
+        uri = URI.parse(metrics_endpoint_url)
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl = (uri.scheme == "https")
+        http.open_timeout = @configuration.open_timeout
+        http.read_timeout = @configuration.read_timeout
+        request = Net::HTTP::Post.new(uri.request_uri)
+        request["Content-Type"] = "application/json"
+        request["Authorization"] = "Bearer #{@configuration.api_key}"
+        request.body = JSON.dump(body)
+        perform_request(http, request, event_name: "heartbeat", apply_settings: true)
+      else
+        dispatch_request(
+          url: metrics_endpoint_url,
+          body: body,
+          event_name: "heartbeat",
+          apply_settings: true
+        )
+      end
 
       nil
     end
@@ -52,7 +67,7 @@ module DeadBro
       return if @configuration.api_key.nil?
       return unless @configuration.enabled
       return if @configuration.skip_tracking?
-      return unless @configuration.job_queue_monitoring_enabled
+      return unless @configuration.monitor_enabled
       return if circuit_open?
 
       body = {payload: payload, sent_at: Time.now.utc.iso8601, revision: @configuration.resolve_deploy_id, gem_version: DeadBro::VERSION}
@@ -206,12 +221,5 @@ module DeadBro
       )
     end
 
-    def log_debug(message)
-      if defined?(Rails) && Rails.respond_to?(:logger) && Rails.logger
-        Rails.logger.debug(message)
-      else
-        $stdout.puts(message)
-      end
-    end
   end
 end

data/lib/dead_bro/collectors/process_info.rb

@@ -18,6 +18,7 @@ module DeadBro
         now = Time.now.utc
 
         {
+          kind: DeadBro.process_kind,
           pid: Process.pid,
           hostname: safe_hostname,
           boot_time: rails_boot_time,

data/lib/dead_bro/configuration.rb

@@ -12,7 +12,7 @@ module DeadBro
     # Remote-managed settings (overwritten by backend JSON `settings` on successful API responses)
     attr_accessor :memory_tracking_enabled, :allocation_tracking_enabled,
       :sample_rate, :slow_query_threshold_ms, :explain_analyze_enabled,
-      :job_queue_monitoring_enabled, :enable_db_stats, :enable_process_stats, :enable_system_stats,
+      :monitor_enabled, :enable_db_stats, :enable_process_stats, :enable_system_stats,
       :max_sql_queries_to_send, :max_logs_to_send
 
     # Readers for exclusion lists. Writers are defined below so we can compile
@@ -58,7 +58,7 @@ module DeadBro
       enabled sample_rate memory_tracking_enabled allocation_tracking_enabled
       explain_analyze_enabled slow_query_threshold_ms max_sql_queries_to_send max_logs_to_send
       excluded_controllers excluded_jobs exclusive_controllers exclusive_jobs
-      job_queue_monitoring_enabled enable_db_stats enable_process_stats enable_system_stats
+      monitor_enabled enable_db_stats enable_process_stats enable_system_stats
     ].freeze
 
     def initialize
@@ -87,7 +87,7 @@ module DeadBro
       self.excluded_jobs = []
       self.exclusive_controllers = []
       self.exclusive_jobs = []
-      @job_queue_monitoring_enabled = false
+      @monitor_enabled = false
       @enable_db_stats = false
       @enable_process_stats = false
       @enable_system_stats = false
@@ -145,7 +145,7 @@ module DeadBro
           when "sample_rate", "slow_query_threshold_ms", "max_sql_queries_to_send", "max_logs_to_send"
             send(:"#{k}=", value.to_i)
           when "enabled", "memory_tracking_enabled", "allocation_tracking_enabled", "explain_analyze_enabled",
-               "job_queue_monitoring_enabled", "enable_db_stats", "enable_process_stats", "enable_system_stats"
+               "monitor_enabled", "enable_db_stats", "enable_process_stats", "enable_system_stats"
             send(:"#{k}=", !!value)
           when "excluded_controllers", "excluded_jobs", "exclusive_controllers", "exclusive_jobs"
             send(:"#{k}=", Array(value).map(&:to_s))

data/lib/dead_bro/elasticsearch_subscriber.rb

@@ -13,12 +13,12 @@ module DeadBro
     end
 
     # Called by HttpInstrumentation when it detects a Net::HTTP request to an ES host.
-    def self.record(method:, path:, status:, duration_ms:)
+    def self.record(method:, path:, status:, duration_ms:, start_offset_ms: nil)
       events = Thread.current[THREAD_LOCAL_KEY]
       return unless events
       return unless should_continue_tracking?
 
-      events << build_event(method, path, status, duration_ms)
+      events << build_event(method, path, status, duration_ms, start_offset_ms)
     rescue
     end
 
@@ -120,20 +120,23 @@ module DeadBro
             duration_ms = ((finished - started) * 1000.0).round(2)
             method = payload[:method].to_s.upcase
             path = payload[:path].to_s
-            events << build_event(method, path, payload[:status], duration_ms)
+            tracking_start = Thread.current[DeadBro::TRACKING_START_TIME_KEY]
+            start_offset_ms = tracking_start ? ((started - tracking_start) * 1000.0).round(2) : nil
+            events << build_event(method, path, payload[:status], duration_ms, start_offset_ms)
           rescue
           end
         end
       rescue
       end
 
-      def build_event(method, path, status, duration_ms)
+      def build_event(method, path, status, duration_ms, start_offset_ms = nil)
         {
           method: method.to_s.upcase,
           path: sanitize_path(path),
           operation: extract_operation(method, path),
           status: status,
-          duration_ms: duration_ms
+          duration_ms: duration_ms,
+          start_offset_ms: start_offset_ms
         }
       end
     end

data/lib/dead_bro/error_middleware.rb

@@ -54,6 +54,7 @@ module DeadBro
         rails_env: DeadBro.env,
         app: safe_app_name,
         pid: Process.pid,
+        process_kind: DeadBro.process_kind,
         logs: DeadBro.logger.logs
       }
     end

data/lib/dead_bro/http_instrumentation.rb

@@ -21,6 +21,7 @@ module DeadBro
       mod = Module.new do
         define_method(:request) do |req, body = nil, &block|
           start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+          wall_start = Time.now
           response = nil
           error = nil
           begin
@@ -46,6 +47,9 @@ module DeadBro
               # must still be tracked; only skip the deadbro backend itself.
               skip_instrumentation = !is_es_host && uri && (uri.to_s.include?("localhost") || uri.to_s.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
                 # Route to elasticsearch subscriber instead of http_outgoing
                 if Thread.current[DeadBro::ElasticsearchSubscriber::THREAD_LOCAL_KEY]
@@ -54,7 +58,8 @@ module DeadBro
                     method: req.method,
                     path: path,
                     status: response && response.code.to_i,
-                    duration_ms: duration_ms
+                    duration_ms: duration_ms,
+                    start_offset_ms: start_offset_ms
                   )
                 end
               elsif !skip_instrumentation
@@ -67,6 +72,7 @@ module DeadBro
                   path: (uri && uri.path) || req.path,
                   status: response && response.code.to_i,
                   duration_ms: duration_ms,
+                  start_offset_ms: start_offset_ms,
                   exception: error && error.class.name
                 }
                 if Thread.current[THREAD_LOCAL_KEY] && DeadBro::HttpInstrumentation.should_continue_tracking?

data/lib/dead_bro/job_subscriber.rb

@@ -115,6 +115,7 @@ module DeadBro
           sql_queries: sql_queries,
           rails_env: DeadBro.env,
           host: safe_host,
+          process_kind: DeadBro.process_kind,
           memory_usage: memory_usage_mb,
           gc_stats: gc_stats,
           memory_events: memory_events,
@@ -213,6 +214,7 @@ module DeadBro
           backtrace: Array(exception&.backtrace).first(50),
           rails_env: DeadBro.env,
           host: safe_host,
+          process_kind: DeadBro.process_kind,
           memory_usage: memory_usage_mb,
           gc_stats: gc_stats,
           memory_events: memory_events,

data/lib/dead_bro/monitor.rb

@@ -24,6 +24,16 @@ module DeadBro
       @running = true
       @thread = Thread.new do
         Thread.current.abort_on_exception = false
+
+        # Fetch initial settings before the first collection tick so processes
+        # that haven't yet posted any metrics (e.g. Sidekiq at boot) still get
+        # monitor_enabled and other remote settings from the backend.
+        begin
+          @client.post_heartbeat(sync: true)
+        rescue => e
+          log_error("Error fetching initial settings: #{e.message}")
+        end
+
         loop do
           break unless @running
 
@@ -59,6 +69,7 @@ module DeadBro
         environment: DeadBro.env,
         host: process_hostname,
         pid: Process.pid,
+        process_kind: DeadBro.process_kind,
         current_time: Time.now.utc.iso8601,
         jobs: DeadBro::Collectors::Jobs.collect,
         network: DeadBro::Collectors::Network.collect
@@ -86,10 +97,11 @@ module DeadBro
     end
 
     def log_error(message)
+      msg = "[DeadBro::Monitor] #{message}"
       if defined?(Rails) && Rails.respond_to?(:logger) && Rails.logger
-        Rails.logger.error("[DeadBro::Monitor] #{message}")
+        Rails.logger.error(msg)
       else
-        $stderr.puts("[DeadBro::Monitor] #{message}")
+        warn(msg)
       end
     end
 

data/lib/dead_bro/railtie.rb

@@ -68,7 +68,7 @@ if defined?(Rails) && defined?(Rails::Railtie)
           end
 
           # Always start the monitor thread. The thread runs every 60s but
-          # post_monitor_stats skips the HTTP POST when job_queue_monitoring_enabled
+          # post_monitor_stats skips the HTTP POST when monitor_enabled
           # is false, so the backend can toggle monitoring on/off mid-process.
           require "dead_bro/monitor"
           DeadBro.monitor = DeadBro::Monitor.new(client: shared_client)

data/lib/dead_bro/redis_subscriber.rb

@@ -63,6 +63,7 @@ module DeadBro
         def record_redis_command(command)
           return yield unless Thread.current[RedisSubscriber::THREAD_LOCAL_KEY]
 
+          wall_start = Time.now
           start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
           error = nil
           begin
@@ -77,12 +78,15 @@ module DeadBro
 
             begin
               cmd_info = extract_command_info(command)
+              tracking_start = Thread.current[DeadBro::TRACKING_START_TIME_KEY]
+              start_offset_ms = tracking_start ? ((wall_start - tracking_start) * 1000.0).round(2) : nil
               event = {
                 event: "redis.command",
                 command: cmd_info[:command],
                 key: cmd_info[:key],
                 args_count: cmd_info[:args_count],
                 duration_ms: duration_ms,
+                start_offset_ms: start_offset_ms,
                 db: safe_db(@db),
                 error: error ? error.class.name : nil
               }
@@ -98,6 +102,7 @@ module DeadBro
         def record_redis_pipeline(pipeline)
           return yield unless Thread.current[RedisSubscriber::THREAD_LOCAL_KEY]
 
+          wall_start = Time.now
           start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
           begin
             result = yield
@@ -108,10 +113,13 @@ module DeadBro
 
             begin
               commands_count = pipeline.commands&.length || 0
+              tracking_start = Thread.current[DeadBro::TRACKING_START_TIME_KEY]
+              start_offset_ms = tracking_start ? ((wall_start - tracking_start) * 1000.0).round(2) : nil
               event = {
                 event: "redis.pipeline",
                 commands_count: commands_count,
                 duration_ms: duration_ms,
+                start_offset_ms: start_offset_ms,
                 db: safe_db(@db)
               }
 
@@ -126,6 +134,7 @@ module DeadBro
         def record_redis_multi(multi)
           return yield unless Thread.current[RedisSubscriber::THREAD_LOCAL_KEY]
 
+          wall_start = Time.now
           start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
           begin
             result = yield
@@ -136,10 +145,13 @@ module DeadBro
 
             begin
               commands_count = multi.commands&.length || 0
+              tracking_start = Thread.current[DeadBro::TRACKING_START_TIME_KEY]
+              start_offset_ms = tracking_start ? ((wall_start - tracking_start) * 1000.0).round(2) : nil
               event = {
                 event: "redis.multi",
                 commands_count: commands_count,
                 duration_ms: duration_ms,
+                start_offset_ms: start_offset_ms,
                 db: safe_db(@db)
               }
 
@@ -201,7 +213,9 @@ module DeadBro
           ActiveSupport::Notifications.subscribe(/\Aredis\..+\z/) do |name, started, finished, _unique_id, data|
             next unless Thread.current[THREAD_LOCAL_KEY]
             duration_ms = ((finished - started) * 1000.0).round(2)
-            event = build_event(name, data, duration_ms)
+            tracking_start = Thread.current[DeadBro::TRACKING_START_TIME_KEY]
+            start_offset_ms = tracking_start ? ((started - tracking_start) * 1000.0).round(2) : nil
+            event = build_event(name, data, duration_ms, start_offset_ms)
             if event && should_continue_tracking?
               Thread.current[THREAD_LOCAL_KEY] << event
             end
@@ -239,7 +253,7 @@ module DeadBro
       true
     end
 
-    def self.build_event(name, data, duration_ms)
+    def self.build_event(name, data, duration_ms, start_offset_ms = nil)
       cmd = extract_command(data)
       {
         event: name.to_s,
@@ -247,6 +261,7 @@ module DeadBro
         key: cmd[:key],
         args_count: cmd[:args_count],
         duration_ms: duration_ms,
+        start_offset_ms: start_offset_ms,
         db: safe_db(data[:db])
       }
     rescue

data/lib/dead_bro/sql_subscriber.rb

@@ -106,6 +106,9 @@ module DeadBro
         duration_ms = ((finished - started) * 1000.0).round(2)
         original_sql = data[:sql]
 
+        tracking_start = Thread.current[DeadBro::TRACKING_START_TIME_KEY]
+        start_offset_ms = tracking_start ? ((started - tracking_start) * 1000.0).round(2) : nil
+
         threshold = begin
           DeadBro.configuration.slow_query_threshold_ms
         rescue
@@ -133,6 +136,7 @@ module DeadBro
           sql: sanitized_sql,
           name: data[:name],
           duration_ms: duration_ms,
+          start_offset_ms: start_offset_ms,
           cached: data[:cached] || false,
           connection_id: data[:connection_id],
           trace: captured_trace,
@@ -167,6 +171,7 @@ module DeadBro
               total_allocations: allocations || 0,
               cached_count:      (data[:cached] ? 1 : 0),
               n_plus_one:        false,
+              start_offset_ms:   start_offset_ms,
               backtrace:         captured_trace,
               explain_plan:      nil
             }

data/lib/dead_bro/subscriber.rb

@@ -134,6 +134,7 @@ module DeadBro
               duration_ms: duration_ms,
               rails_env: DeadBro.env,
               host: safe_host,
+              process_kind: DeadBro.process_kind,
               params: safe_params(data),
               user_agent: safe_user_agent(data),
               user_id: extract_user_id(data),
@@ -166,6 +167,7 @@ module DeadBro
           db_runtime_ms: data[:db_runtime],
           host: safe_host,
           rails_env: DeadBro.env,
+          process_kind: DeadBro.process_kind,
           params: safe_params(data),
           user_agent: safe_user_agent(data),
           user_id: extract_user_id(data),

data/lib/dead_bro/version.rb

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

data/lib/dead_bro/view_rendering_subscriber.rb

@@ -14,24 +14,30 @@ module DeadBro
 
     def self.subscribe!(client: Client.new)
       ActiveSupport::Notifications.subscribe(RENDER_TEMPLATE_EVENT) do |_name, started, finished, _uid, data|
+        tracking_start = Thread.current[DeadBro::TRACKING_START_TIME_KEY]
         add_view_event(type: "template", identifier: safe_identifier(data[:identifier]),
                        duration_ms: ((finished - started) * 1000.0).round(2),
-                       rendered_at: Time.now.utc.to_i)
+                       rendered_at: Time.now.utc.to_i,
+                       start_offset_ms: tracking_start ? ((started - tracking_start) * 1000.0).round(2) : nil)
       end
 
       ActiveSupport::Notifications.subscribe(RENDER_PARTIAL_EVENT) do |_name, started, finished, _uid, data|
+        tracking_start = Thread.current[DeadBro::TRACKING_START_TIME_KEY]
         add_view_event(type: "partial", identifier: safe_identifier(data[:identifier]),
                        duration_ms: ((finished - started) * 1000.0).round(2),
                        cache_key: data[:cache_key],
-                       rendered_at: Time.now.utc.to_i)
+                       rendered_at: Time.now.utc.to_i,
+                       start_offset_ms: tracking_start ? ((started - tracking_start) * 1000.0).round(2) : nil)
       end
 
       ActiveSupport::Notifications.subscribe(RENDER_COLLECTION_EVENT) do |_name, started, finished, _uid, data|
+        tracking_start = Thread.current[DeadBro::TRACKING_START_TIME_KEY]
         add_view_event(type: "collection", identifier: safe_identifier(data[:identifier]),
                        duration_ms: ((finished - started) * 1000.0).round(2),
                        collection_count: (data[:count] || 0).to_i,
                        collection_cached_count: (data[:cached_count] || 0).to_i,
-                       rendered_at: Time.now.utc.to_i)
+                       rendered_at: Time.now.utc.to_i,
+                       start_offset_ms: tracking_start ? ((started - tracking_start) * 1000.0).round(2) : nil)
       end
     rescue
     end
@@ -80,7 +86,8 @@ module DeadBro
           rendered_at_max:         rendered_at,
           cache_hit_count:         (view_info[:cache_key] ? 1 : 0),
           collection_count:        view_info[:collection_count].to_i,
-          collection_cached_count: view_info[:collection_cached_count].to_i
+          collection_cached_count: view_info[:collection_cached_count].to_i,
+          start_offset_ms:         view_info[:start_offset_ms]
         }
       end
     end

data/lib/dead_bro.rb

@@ -127,6 +127,30 @@ module DeadBro
     "development"
   end
 
+  def self.process_kind
+    @process_kind ||= begin
+      fingerprint = "#{$PROGRAM_NAME} #{process_command_line}".downcase
+      case
+      when fingerprint.match?(/sidekiq|good_job|solid_queue|delayed_job/) then "worker"
+      when fingerprint.match?(/puma|passenger|unicorn|falcon/)            then "web"
+      when fingerprint.include?("console")                                then "console"
+      when fingerprint.include?("rake")                                   then "task"
+      else "app"
+      end
+    end
+  rescue
+    "app"
+  end
+
+  def self.process_command_line
+    # /proc/self/cmdline is Linux-only; on macOS/Windows the fallback to
+    # $PROGRAM_NAME is used, which may miss some process fingerprints (e.g.
+    # a Sidekiq invocation that uses a wrapper script).
+    File.readable?("/proc/self/cmdline") ? File.read("/proc/self/cmdline").tr("\0", " ").strip : $PROGRAM_NAME.to_s
+  rescue
+    $PROGRAM_NAME.to_s
+  end
+
   # Returns the monitor instance
   def self.monitor
     @monitor

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: dead_bro
 version: !ruby/object:Gem::Version
-  version: 0.2.19
+  version: 0.2.21
 platform: ruby
 authors:
 - Emanuel Comsa
@@ -18,7 +18,6 @@ extensions: []
 extra_rdoc_files: []
 files:
 - CHANGELOG.md
-- FEATURES.md
 - README.md
 - lib/dead_bro.rb
 - lib/dead_bro/ar_object_tracker.rb
@@ -75,7 +74,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.9
+rubygems_version: 4.0.10
 specification_version: 4
 summary: Minimal APM for Rails apps.
 test_files: []

data/FEATURES.md

@@ -1,333 +0,0 @@
-# ApmBro Feature List
-
-A comprehensive feature list for comparing ApmBro with other APM (Application Performance Monitoring) tools.
-
-## Core Architecture
-
-- **Rails Integration**: Automatic subscription to Rails events via ActiveSupport::Notifications
-- **Zero-Configuration Setup**: Works out of the box with minimal configuration
-- **Asynchronous Metrics Posting**: Non-blocking HTTP requests using background threads
-- **Thread-Local Storage**: Per-request metric collection using thread-local variables
-- **Circuit Breaker Pattern**: Built-in circuit breaker to prevent cascading failures when APM endpoint is down
-- **Deploy Tracking**: Automatic deploy ID resolution from multiple sources (Rails settings, ENV vars, Heroku, Git)
-
-## Request Tracking
-
-### Controller Action Monitoring
-- **Automatic Tracking**: Tracks all controller actions automatically
-- **Request Duration**: Measures total request processing time
-- **HTTP Method & Path**: Captures HTTP method and request path
-- **Status Codes**: Tracks HTTP response status codes
-- **View Runtime**: Separate tracking of view rendering time
-- **Database Runtime**: Separate tracking of database query time
-- **Request Parameters**: Captures request parameters (with sensitive data filtering)
-- **User Agent**: Tracks user agent strings
-- **User ID Extraction**: Extracts authenticated user ID (supports Warden)
-- **Environment Context**: Tracks Rails environment (development, staging, production)
-
-### Request Sampling
-- **Configurable Sample Rate**: Percentage-based sampling (1-100%)
-- **Random Sampling**: Each request has random chance of being tracked
-- **Consistent Per-Request**: Sampling decision applies to all metrics for a request
-- **Error Override**: Errors are always tracked regardless of sampling
-- **Cost Optimization**: Reduces data volume and costs for high-traffic applications
-
-### Exclusion Rules
-- **Controller Exclusion**: Exclude entire controllers from tracking
-- **Action Exclusion**: Exclude specific controller#action combinations
-- **Wildcard Support**: Pattern matching with `*` wildcards (e.g., `Admin::*`, `Admin::*#*`)
-- **Job Exclusion**: Exclude specific background jobs from tracking
-- **Flexible Configuration**: Configure via initializer, Rails settings, or environment variables
-
-## SQL Query Tracking
-
-### Query Details
-- **Full SQL Tracking**: Captures all SQL queries executed during requests and jobs
-- **Query Sanitization**: Automatically sanitizes SQL to remove sensitive data
-- **Query Name**: Tracks query names (e.g., "User Load", "User Update")
-- **Duration Measurement**: Precise query execution time in milliseconds
-- **Cache Detection**: Identifies cached queries
-- **Connection ID**: Tracks database connection ID
-- **Call Stack Traces**: Full backtrace showing where queries were executed
-- **Object Allocations**: Optional tracking of object allocations per query
-
-### Query Performance Analysis
-- **Slow Query Detection**: Configurable threshold for identifying slow queries
-- **EXPLAIN ANALYZE**: Automatic execution plan capture for slow queries
-- **Background Execution**: EXPLAIN ANALYZE runs in separate thread (non-blocking)
-- **Multi-Database Support**: Works with PostgreSQL, MySQL, SQLite, and others
-- **Smart Filtering**: Automatically skips transaction queries (BEGIN, COMMIT, ROLLBACK)
-- **Execution Plan Details**: 
-  - PostgreSQL: Full EXPLAIN ANALYZE with buffer usage statistics
-  - MySQL: EXPLAIN ANALYZE with actual execution times
-  - SQLite: EXPLAIN QUERY PLAN output
-- **Query Optimization Insights**: Helps identify missing indexes, full table scans, JOIN issues
-
-## View Rendering Tracking
-
-### View Performance
-- **Template Rendering**: Tracks main template rendering
-- **Partial Rendering**: Tracks partial template rendering with cache key information
-- **Collection Rendering**: Tracks collection rendering (partials in loops)
-- **Rendering Duration**: Precise timing for each view component
-- **Virtual Path Tracking**: Tracks view virtual paths
-- **Layout Information**: Captures layout usage
-
-### View Analysis
-- **Slow View Detection**: Identifies the slowest rendering views
-- **Frequency Analysis**: Tracks most frequently rendered views
-- **Cache Hit Rate**: Calculates cache hit rates for partials
-- **Collection Cache Analysis**: Tracks cache hit rates for collection rendering
-- **Performance Metrics**: 
-  - Total views rendered per request
-  - Total view rendering duration
-  - Average view rendering duration
-  - Breakdown by view type (template, partial, collection)
-
-## Memory Tracking & Leak Detection
-
-### Lightweight Memory Tracking (Default)
-- **Memory Usage Monitoring**: Tracks memory consumption per request using GC stats
-- **Memory Growth Tracking**: Measures memory growth during request processing
-- **GC Statistics**: Tracks garbage collection count and heap pages
-- **Minimal Performance Impact**: ~0.1ms overhead per request
-- **Memory Before/After**: Captures memory state at request start and end
-
-### Detailed Allocation Tracking (Optional)
-- **Object Allocation Tracking**: Detailed tracking of object allocations (disabled by default)
-- **Allocation Sampling**: Configurable sampling rate for allocations
-- **Large Object Detection**: Identifies objects larger than 1MB threshold
-- **Memory Snapshots**: Periodic memory snapshots during request processing
-- **Object Count Tracking**: Tracks object counts before and after requests
-- **Performance Impact**: ~2-5ms overhead per request (only when enabled)
-
-### Memory Leak Detection
-- **Pattern Detection**: Detects growing memory patterns over time
-- **GC Efficiency Analysis**: Monitors garbage collection effectiveness
-- **Heap Page Tracking**: Tracks heap page growth
-- **Request Correlation**: Correlates memory growth with specific controllers/actions
-
-## Background Job Tracking
-
-### Job Execution Monitoring
-- **ActiveJob Integration**: Automatic tracking when ActiveJob is available
-- **Job Class Tracking**: Tracks job class names
-- **Job ID**: Captures unique job identifiers
-- **Queue Name**: Tracks which queue processed the job
-- **Job Arguments**: Captures job arguments (with sensitive data filtering)
-- **Duration Measurement**: Precise job execution time in milliseconds
-- **Status Tracking**: Tracks job status (completed or failed)
-
-### Job Error Tracking
-- **Exception Capture**: Captures exceptions from failed jobs
-- **Exception Class**: Tracks exception class names
-- **Exception Messages**: Captures exception messages (truncated to 1000 chars)
-- **Backtraces**: Full exception backtraces (first 50 lines)
-- **SQL Query Context**: Includes SQL queries executed during failed jobs
-- **Memory Context**: Includes memory usage during job execution
-
-### Job SQL Tracking
-- **SQL Query Tracking**: Tracks all SQL queries executed during job processing
-- **Query Details**: Same detailed SQL tracking as request tracking
-- **Query Context**: Full context of database operations in background jobs
-
-## Cache Tracking
-
-### Cache Operations
-- **Read Operations**: Tracks cache read operations
-- **Write Operations**: Tracks cache write operations
-- **Delete Operations**: Tracks cache delete operations
-- **Existence Checks**: Tracks cache existence checks
-- **Fetch Operations**: Tracks cache fetch with hit/miss detection
-- **Multi-Read Operations**: Tracks cache read_multi operations
-- **Multi-Write Operations**: Tracks cache write_multi operations
-- **Cache Generation**: Tracks cache generation events
-
-### Cache Analysis
-- **Cache Hit Detection**: Identifies cache hits vs misses
-- **Cache Key Tracking**: Tracks cache keys (truncated to 200 chars)
-- **Store Information**: Identifies which cache store was used
-- **Namespace Tracking**: Tracks cache namespaces
-- **Duration Measurement**: Precise timing for each cache operation
-- **Hit Rate Calculation**: Calculates cache hit rates per request
-
-## Redis Tracking
-
-### Redis Command Tracking
-- **Command Monitoring**: Tracks all Redis commands executed
-- **Command Name**: Captures Redis command names (GET, SET, etc.)
-- **Key Tracking**: Tracks Redis keys (truncated to 200 chars)
-- **Argument Count**: Tracks number of arguments per command
-- **Database Selection**: Tracks which Redis database is used
-- **Duration Measurement**: Precise timing for each Redis command
-- **Error Tracking**: Captures Redis command errors
-
-### Advanced Redis Features
-- **Pipeline Support**: Tracks Redis pipeline operations with command counts
-- **Multi/Transaction Support**: Tracks Redis MULTI/EXEC transactions
-- **ActiveSupport Integration**: Subscribes to ActiveSupport::Notifications for Redis events
-- **Client Instrumentation**: Direct instrumentation of Redis::Client for comprehensive coverage
-
-## Error Tracking
-
-### Exception Handling
-- **Automatic Exception Capture**: Captures exceptions from controller actions
-- **Exception Class**: Tracks exception class names
-- **Exception Messages**: Captures exception messages (truncated to 1000 chars)
-- **Full Backtraces**: Captures complete exception backtraces (first 50 lines)
-- **Request Context**: Includes full request context with exceptions
-- **Error Flagging**: Errors are marked and always tracked (even with sampling)
-
-### Error Context
-- **Controller/Action**: Identifies where the error occurred
-- **Request Parameters**: Includes request parameters at time of error
-- **User Information**: Includes user ID if available
-- **SQL Queries**: Includes SQL queries executed before error
-- **Memory State**: Includes memory usage at time of error
-- **Log Messages**: Includes application logs captured during request
-
-## HTTP Instrumentation
-
-### Outgoing HTTP Tracking
-- **HTTP Request Tracking**: Tracks outgoing HTTP requests (via middleware)
-- **Request Context**: Captures HTTP request details
-- **Response Context**: Captures HTTP response details
-- **Duration Measurement**: Tracks HTTP request duration
-
-## Configuration & Flexibility
-
-### Configuration Options
-- **API Key Management**: Multiple sources (config, Rails credentials, ENV)
-- **Endpoint Configuration**: Configurable endpoint URL
-- **Timeout Settings**: Configurable open and read timeouts
-- **Enable/Disable Toggle**: Can be enabled/disabled via configuration
-- **Environment Detection**: Automatic Rails environment detection
-
-### Circuit Breaker Configuration
-- **Failure Threshold**: Configurable failure threshold (default: 3)
-- **Recovery Timeout**: Configurable recovery timeout (default: 60 seconds)
-- **Retry Timeout**: Configurable retry timeout (default: 300 seconds)
-- **Enable/Disable**: Can enable/disable circuit breaker
-
-### Memory Tracking Configuration
-- **Memory Tracking Toggle**: Enable/disable memory tracking
-- **Allocation Tracking Toggle**: Enable/disable detailed allocation tracking
-- **Sampling Configuration**: Configurable request sampling rate
-
-### Query Analysis Configuration
-- **Slow Query Threshold**: Configurable threshold in milliseconds (default: 500ms)
-- **EXPLAIN ANALYZE Toggle**: Enable/disable automatic EXPLAIN ANALYZE
-
-## Data Safety & Privacy
-
-### Data Sanitization
-- **SQL Sanitization**: Automatically sanitizes SQL queries
-- **Parameter Filtering**: Filters sensitive parameters (password, token, secret, key)
-- **Argument Truncation**: Limits and truncates job arguments
-- **Key Truncation**: Truncates cache and Redis keys to 200 characters
-- **Value Truncation**: Recursively truncates nested values to prevent huge payloads
-- **String Limits**: Limits string values (e.g., user agent to 200 chars, messages to 1000 chars)
-
-### Data Limits
-- **Array Limits**: Limits array sizes (e.g., first 10 job arguments, first 5 array elements)
-- **Hash Limits**: Limits hash key counts (e.g., first 20 hash keys, first 30 params)
-- **Backtrace Limits**: Limits backtraces to first 50 lines
-- **Allocation Limits**: Limits allocations tracked per request (max 1000)
-
-## Performance & Reliability
-
-### Performance Optimizations
-- **Asynchronous Posting**: Non-blocking HTTP requests
-- **Lightweight Default Mode**: Minimal overhead in default configuration
-- **Sampling Support**: Reduces data volume for high-traffic applications
-- **Thread-Local Storage**: Efficient per-request data collection
-- **Background EXPLAIN**: EXPLAIN ANALYZE runs in background thread
-
-### Reliability Features
-- **Circuit Breaker**: Prevents cascading failures
-- **Error Handling**: Comprehensive error handling to prevent instrumentation failures
-- **Graceful Degradation**: Continues working even if some features fail
-- **Timeout Protection**: Configurable timeouts prevent hanging requests
-
-## Integration & Compatibility
-
-### Framework Support
-- **Rails Integration**: Full Rails integration via Railtie
-- **ActiveSupport Notifications**: Uses ActiveSupport::Notifications for event subscription
-- **ActiveRecord Integration**: Tracks ActiveRecord SQL queries
-- **ActiveJob Integration**: Tracks ActiveJob background jobs
-- **ActionView Integration**: Tracks ActionView rendering
-
-### Database Support
-- **PostgreSQL**: Full support with EXPLAIN ANALYZE
-- **MySQL**: Full support with EXPLAIN ANALYZE
-- **SQLite**: Full support with EXPLAIN QUERY PLAN
-- **Other Databases**: Basic support with standard EXPLAIN
-
-### Cache Store Support
-- **All Cache Stores**: Works with any Rails cache store
-- **Multi-Store Support**: Tracks cache operations across different stores
-
-### Redis Support
-- **Redis Gem**: Works with redis gem
-- **Client Instrumentation**: Direct instrumentation of Redis::Client
-- **Pipeline Support**: Tracks Redis pipelines
-- **Transaction Support**: Tracks Redis MULTI/EXEC transactions
-
-## Logging & Debugging
-
-### Application Logging
-- **Log Capture**: Captures application logs during request processing
-- **Log Context**: Includes logs in metric payloads
-- **Debug Logging**: Optional debug logging for skipped requests
-
-## Deployment & Environment
-
-### Deploy Tracking
-- **Deploy ID Resolution**: Multiple sources for deploy identification (`Configuration#deploy_id=` wins when set, then ENV in `Configuration::DEPLOY_REVISION_ENV_KEYS` order—including `DEAD_BRO_DEPLOY_ID`, git/CI vars, `DD_VERSION`, etc.), otherwise a **per-process UUID** (fine for single dyno/process; unusable alone for fleets like ECS replicas)
-- **Revision Tracking**: Includes deploy/revision ID in all metric payloads
-
-### Environment Support
-- **Rails Environment**: Automatic Rails environment detection
-- **Rack Environment**: Fallback to RACK_ENV or RAILS_ENV
-- **Environment Context**: Includes environment in all metric payloads
-
-## Data Collection & Transmission
-
-### Metric Payload Structure
-- **Structured Data**: Well-structured JSON payloads
-- **Event Names**: Descriptive event names for different metric types
-- **Timestamp Tracking**: ISO8601 timestamps for all metrics
-- **Metadata**: Rich metadata including environment, host, deploy ID
-
-### HTTP Client
-- **HTTPS Support**: Secure HTTPS communication
-- **Bearer Token Auth**: API key authentication via Bearer tokens
-- **JSON Encoding**: JSON-encoded payloads
-- **Custom Headers**: Proper Content-Type and Authorization headers
-
-## Comparison-Ready Features
-
-### Unique Differentiators
-1. **Automatic EXPLAIN ANALYZE**: Background execution plan capture for slow queries
-2. **Lightweight Memory Tracking**: Low-overhead memory monitoring by default
-3. **Comprehensive Cache Tracking**: Detailed cache operation tracking
-4. **Redis Instrumentation**: Full Redis command tracking including pipelines
-5. **View Rendering Analysis**: Detailed view performance analysis with cache hit rates
-6. **Flexible Exclusion Rules**: Wildcard support for controller/job exclusion
-7. **Request Sampling**: Configurable percentage-based sampling
-8. **Circuit Breaker**: Built-in resilience for APM endpoint failures
-9. **Multi-Source Configuration**: Flexible configuration from multiple sources
-10. **Deploy Tracking**: Automatic deploy ID resolution from multiple sources
-
-### Standard APM Features
-- Request/response tracking
-- SQL query tracking
-- Error tracking
-- Background job tracking
-- Memory tracking
-- Performance metrics
-- Exception handling
-- User context
-- Environment tracking
-