dead_bro 0.2.20 → 0.2.22

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 46ac9efa7b56801c96f5f9e20f113613fa60c10337b94ee84adc59d0ea38234f
-  data.tar.gz: fa10f3f9436a350d8cea97caa71541ade145c88e479cd84195a2814dc43e4395
+  metadata.gz: 14aa1509e04c9bf1848883cc5f2a12e7783e5ac4c123c9bcddde301948e30bfb
+  data.tar.gz: b3ec01b52a1e63efda701520a014f040fff96cedcbf36fe0827f4a7e892aac90
 SHA512:
-  metadata.gz: 935d4045021860632e6121b844afe1adca986297e03b0c54c0322721b6877112e1dd1e34ccda5ad1b91d52a6a5a05e829fc8c5f045ad74623d6a1b0a5e19ef66
-  data.tar.gz: 9171b13a16ba440015e4df1e44f260b362224c8f0ed8752f6c1a3420c97667f35ffffc97879ed2c34a829be2f95b216b552bb5b52525aa1403c988d1c3955b24
+  metadata.gz: 0c1f24b1718fa9aacf383d22e3b6982e76e7c5aa2c1ccf989d9c411bb0771b0a5fae60d9a780bbe845fac84cafc1a7f876b305005b9e5f3c07f82a7005b0775b
+  data.tar.gz: 469f652352cb2544b882b82dc528dced3e4725a34da033a14dd54b6e7742691a189eed1079dac1684e2da24ba587a955d4fcf3034c1c50f6a2f0d9bf514b2311

data/CHANGELOG.md

@@ -3,6 +3,39 @@
 ### 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
@@ -13,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/cpu_tracker.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module DeadBro
+  module CpuTracker
+    THREAD_KEY = :dead_bro_cpu_start
+
+    def self.start_request_tracking
+      Thread.current[THREAD_KEY] = thread_cpu_ms
+    end
+
+    def self.stop_request_tracking
+      before = Thread.current[THREAD_KEY]
+      return nil if before.nil?
+      after = thread_cpu_ms
+      return nil if after.nil?
+      (after - before).round(2)
+    ensure
+      Thread.current[THREAD_KEY] = nil
+    end
+
+    def self.thread_cpu_ms
+      Process.clock_gettime(Process::CLOCK_THREAD_CPUTIME_ID, :millisecond)
+    rescue
+      nil
+    end
+  end
+end

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/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/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/sql_tracking_middleware.rb

@@ -67,6 +67,9 @@ module DeadBro
       # Start AR object instantiation counting for this request
       DeadBro::ArObjectTracker.start_request_tracking if defined?(DeadBro::ArObjectTracker)
 
+      # Start CPU time tracking for this request (thread-local clock)
+      DeadBro::CpuTracker.start_request_tracking if defined?(DeadBro::CpuTracker)
+
       # Start outgoing HTTP accumulation for this request
       Thread.current[:dead_bro_http_events] = []
 
@@ -106,6 +109,7 @@ module DeadBro
       Thread.current[DeadBro::GcTracker::THREAD_KEY] = nil if defined?(DeadBro::GcTracker)
       # Bypass stop_request_tracking intentionally — cleanup only, no return value needed here.
       Thread.current[DeadBro::ArObjectTracker::THREAD_KEY] = nil if defined?(DeadBro::ArObjectTracker)
+      Thread.current[DeadBro::CpuTracker::THREAD_KEY] = nil if defined?(DeadBro::CpuTracker)
       Thread.current[DeadBro::TRACKING_START_TIME_KEY] = nil
     end
 

data/lib/dead_bro/subscriber.rb

@@ -72,6 +72,9 @@ module DeadBro
         # Stop AR object instantiation tracking
         ar_instantiation_count = defined?(DeadBro::ArObjectTracker) ? DeadBro::ArObjectTracker.stop_request_tracking : nil
 
+        # Stop CPU time tracking — thread CPU time consumed by this request
+        cpu_time_ms = defined?(DeadBro::CpuTracker) ? DeadBro::CpuTracker.stop_request_tracking : nil
+
         # Stop view rendering tracking and get collected view events
         view_events = DeadBro::ViewRenderingSubscriber.stop_request_tracking
         view_performance = DeadBro::ViewRenderingSubscriber.analyze_view_performance(view_events)
@@ -191,6 +194,7 @@ module DeadBro
           db_connection_checkouts: db_connection_stats[:checkouts],
           gc_pressure: gc_pressure,
           ar_instantiation_count: ar_instantiation_count,
+          cpu_time_ms: cpu_time_ms,
           logs: DeadBro.logger.logs
         }
         client.post_metric(event_name: name, payload: payload)
@@ -214,13 +218,14 @@ module DeadBro
       DeadBro::DbConnectionSubscriber.stop_request_tracking if defined?(DeadBro::DbConnectionSubscriber)
       DeadBro::GcTracker.stop_request_tracking if defined?(DeadBro::GcTracker)
       DeadBro::ArObjectTracker.stop_request_tracking if defined?(DeadBro::ArObjectTracker)
+      DeadBro::CpuTracker.stop_request_tracking if defined?(DeadBro::CpuTracker)
     rescue
       # Best effort — draining must never raise from the notifications callback.
     end
 
     def self.safe_path(data)
       path = data[:path] || (data[:request] && data[:request].path)
-      path.to_s
+      sanitize_string(path)
     rescue
       ""
     end
@@ -266,11 +271,16 @@ module DeadBro
       {}
     end
 
+    def self.sanitize_string(str)
+      str.to_s.gsub("\x00", "")
+    end
+
     # Recursively truncate values to reasonable sizes to avoid huge payloads
     def self.truncate_value(value, max_str: 200, max_array: 20, max_hash_keys: 30)
       case value
       when String
-        (value.length > max_str) ? value[0, max_str] + "…" : value
+        sanitized = sanitize_string(value)
+        (sanitized.length > max_str) ? sanitized[0, max_str] + "…" : sanitized
       when Numeric, TrueClass, FalseClass, NilClass
         value
       when Array
@@ -295,7 +305,7 @@ module DeadBro
           elsif data[:request].respond_to?(:env)
             ua = data[:request].env && data[:request].env["HTTP_USER_AGENT"]
           end
-          return ua.to_s[0..200]
+          return sanitize_string(ua)[0..200]
         end
 
         # Fallback to headers object/hash if present in notification data
@@ -303,7 +313,7 @@ module DeadBro
           headers = data[:headers]
           if headers.respond_to?(:[])
             ua = headers["HTTP_USER_AGENT"] || headers["User-Agent"] || headers["user-agent"]
-            return ua.to_s[0..200]
+            return sanitize_string(ua)[0..200]
           elsif headers.respond_to?(:to_h)
             h = begin
               headers.to_h
@@ -311,14 +321,14 @@ module DeadBro
               {}
             end
             ua = h["HTTP_USER_AGENT"] || h["User-Agent"] || h["user-agent"]
-            return ua.to_s[0..200]
+            return sanitize_string(ua)[0..200]
           end
         end
 
         # Fallback to env hash if present in notification data
         if data[:env].is_a?(Hash)
           ua = data[:env]["HTTP_USER_AGENT"]
-          return ua.to_s[0..200]
+          return sanitize_string(ua)[0..200]
         end
 
         ""

data/lib/dead_bro/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module DeadBro
-  VERSION = "0.2.20"
+  VERSION = "0.2.22"
 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

@@ -20,6 +20,7 @@ module DeadBro
   autoload :LightweightMemoryTracker, "dead_bro/lightweight_memory_tracker"
   autoload :GcTracker, "dead_bro/gc_tracker"
   autoload :ArObjectTracker, "dead_bro/ar_object_tracker"
+  autoload :CpuTracker, "dead_bro/cpu_tracker"
   autoload :MemoryHelpers, "dead_bro/memory_helpers"
   autoload :JobSubscriber, "dead_bro/job_subscriber"
   autoload :JobSqlTrackingMiddleware, "dead_bro/job_sql_tracking_middleware"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: dead_bro
 version: !ruby/object:Gem::Version
-  version: 0.2.20
+  version: 0.2.22
 platform: ruby
 authors:
 - Emanuel Comsa
@@ -33,6 +33,7 @@ files:
 - lib/dead_bro/collectors/sample_store.rb
 - lib/dead_bro/collectors/system.rb
 - lib/dead_bro/configuration.rb
+- lib/dead_bro/cpu_tracker.rb
 - lib/dead_bro/db_connection_subscriber.rb
 - lib/dead_bro/dispatcher.rb
 - lib/dead_bro/elasticsearch_subscriber.rb