dead_bro 0.2.5 → 0.2.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 95efdf7e1aadb84f27739eb59612c8ad3bf0c6a5315d12497322140fdd0ca676
-  data.tar.gz: c9285dd8f024f10d974b04b76e98a79f365bb6e07ab1fa665a8340cc34bc69e7
+  metadata.gz: 9a78b3a99d00159acb1bf2fd97a0eed54ba0e03a24d7bbd2ec840e4bf779107f
+  data.tar.gz: 53aba3dcf00e53f210020529413561812de25b3399db8ce040b9976ab798e8d1
 SHA512:
-  metadata.gz: 7b12f73db0672c45f624b0a3916b65c95c8d0929e491ef173832b5f960cfb073b2cf0b337a2071908f5a4bbe768551e851747c56e5a90a704c76719e13449773
-  data.tar.gz: b99e770dae2b68d773eee279b02c78821244bf9c0322e91776301611d0204a0ebdd3c3b5e0c4bf62aec9e5a403bdb4c66ee35f29907fb7d5e68ae978eca33c4d
+  metadata.gz: c150a7a452b46c4a600afbccb4a520a2f52b0c0bb3a85fec8f0a41f0ece56ea5161575a30a15002c18a8fa2b82e5692ccf13e49920ea3fffc031f7d23188027b
+  data.tar.gz: 22b3ea56482f38005ccbd98eae13be751fade782a69f355573ccd49fb2524e3f9bd2c9e40128df5bbb0c2e521924d7f8cba2c49c41a88ad67efafb6041c2f50d

data/lib/dead_bro/client.rb

@@ -31,6 +31,9 @@ module DeadBro
         end
       end
 
+      # Truncate large arrays to avoid 413 Request Entity Too Large
+      payload = truncate_payload_for_request(payload)
+
       # Make the HTTP request (async)
       make_http_request(event_name, payload, @configuration.api_key)
 
@@ -62,6 +65,28 @@ module DeadBro
 
     private
 
+    # Limit payload size to avoid 413 from nginx/reverse proxies. Returns a new hash.
+    def truncate_payload_for_request(payload)
+      return payload unless payload.is_a?(Hash)
+
+      max_sql = @configuration.respond_to?(:max_sql_queries_to_send) ? @configuration.max_sql_queries_to_send : 500
+      max_logs = @configuration.respond_to?(:max_logs_to_send) ? @configuration.max_logs_to_send : 100
+
+      out = payload.dup
+
+      if out.key?(:sql_queries) && out[:sql_queries].is_a?(Array) && out[:sql_queries].size > max_sql
+        out[:sql_queries_total_count] = out[:sql_queries].size
+        out[:sql_queries] = out[:sql_queries].first(max_sql)
+      end
+
+      if out.key?(:logs) && out[:logs].is_a?(Array) && out[:logs].size > max_logs
+        out[:logs_total_count] = out[:logs].size
+        out[:logs] = out[:logs].first(max_logs)
+      end
+
+      out
+    end
+
     def create_circuit_breaker
       return nil unless @configuration.circuit_breaker_enabled
 

data/lib/dead_bro/configuration.rb

@@ -7,7 +7,7 @@ module DeadBro
       :circuit_breaker_retry_timeout, :sample_rate, :excluded_controllers, :excluded_jobs,
       :exclusive_controllers, :exclusive_jobs, :deploy_id, :slow_query_threshold_ms, :explain_analyze_enabled,
       :job_queue_monitoring_enabled, :enable_db_stats, :enable_process_stats, :enable_system_stats,
-      :disk_paths, :interfaces_ignore
+      :disk_paths, :interfaces_ignore, :max_sql_queries_to_send, :max_logs_to_send
 
     def initialize
       @api_key = nil
@@ -36,6 +36,8 @@ module DeadBro
       @enable_system_stats = false
       @disk_paths = ["/"]
       @interfaces_ignore = %w[lo lo0 docker0]
+      @max_sql_queries_to_send = 500 # Cap to avoid 413 Request Entity Too Large
+      @max_logs_to_send = 100
     end
 
     def resolve_deploy_id

data/lib/dead_bro/job_subscriber.rb

@@ -30,7 +30,7 @@ module DeadBro
 
         # Ensure tracking was started (fallback if perform_start.active_job didn't fire)
         # This handles job backends that don't emit perform_start events
-        unless Thread.current[DeadBro::SqlSubscriber::THREAD_LOCAL_KEY]
+        unless DeadBro::SqlSubscriber.tracking_active?
           DeadBro.logger.clear
           Thread.current[DeadBro::TRACKING_START_TIME_KEY] = Time.now
           DeadBro::SqlSubscriber.start_request_tracking
@@ -103,10 +103,10 @@ module DeadBro
 
         duration_ms = ((finished - started) * 1000.0).round(2)
         exception = data[:exception_object]
+        job_class = data[:job].class.name
 
         # Ensure tracking was started (fallback if perform_start.active_job didn't fire)
-        # This handles job backends that don't emit perform_start events
-        unless Thread.current[DeadBro::SqlSubscriber::THREAD_LOCAL_KEY]
+        unless DeadBro::SqlSubscriber.tracking_active?
           DeadBro.logger.clear
           Thread.current[DeadBro::TRACKING_START_TIME_KEY] = Time.now
           DeadBro::SqlSubscriber.start_request_tracking

data/lib/dead_bro/lightweight_memory_tracker.rb

@@ -8,19 +8,25 @@ module DeadBro
     def self.start_request_tracking
       return unless DeadBro.configuration.memory_tracking_enabled
 
-      # Only track essential metrics to minimize overhead
-      Thread.current[THREAD_LOCAL_KEY] = {
+      # Stack allows nested job tracking (e.g. one job performing others in the same thread)
+      mem_before = lightweight_memory_usage
+      frame = {
         gc_before: lightweight_gc_stats,
-        memory_before: lightweight_memory_usage,
+        memory_before: mem_before,
         start_time: Process.clock_gettime(Process::CLOCK_MONOTONIC)
       }
+      (Thread.current[THREAD_LOCAL_KEY] ||= []) << frame
     end
 
     def self.stop_request_tracking
-      events = Thread.current[THREAD_LOCAL_KEY]
-      Thread.current[THREAD_LOCAL_KEY] = nil
+      stack = Thread.current[THREAD_LOCAL_KEY]
+      unless stack.is_a?(Array) && stack.any?
+        Thread.current[THREAD_LOCAL_KEY] = nil
+        return {}
+      end
 
-      return {} unless events
+      events = stack.pop
+      Thread.current[THREAD_LOCAL_KEY] = nil if stack.empty?
 
       # Calculate only essential metrics
       gc_after = lightweight_gc_stats

data/lib/dead_bro/memory_tracking_subscriber.rb

@@ -6,6 +6,7 @@ module DeadBro
   class MemoryTrackingSubscriber
     # Object allocation events
     ALLOCATION_EVENT = "object_allocations.active_support"
+    PROCESS_ACTION_EVENT = "process_action.action_controller"
 
     THREAD_LOCAL_KEY = :dead_bro_memory_events
     # Consider objects larger than this many bytes as "large"
@@ -28,6 +29,23 @@ module DeadBro
             next unless rand < ALLOCATION_SAMPLING_RATE
             track_allocation(data, started, finished)
           end
+
+          # Subscribe to process_action to capture request-level allocation counters
+          ActiveSupport::Notifications.subscribe(PROCESS_ACTION_EVENT) do |*args|
+            event = if args.length == 1 && args.first.is_a?(ActiveSupport::Notifications::Event)
+              args.first
+            else
+              ActiveSupport::Notifications::Event.new(*args)
+            end
+            allocations = event.respond_to?(:allocations) ? event.allocations : event.payload[:allocations]
+            allocated_bytes = event.respond_to?(:allocated_bytes) ? event.allocated_bytes : event.payload[:allocated_bytes]
+            next unless allocations || allocated_bytes
+
+            record_request_allocations(
+              allocations: allocations,
+              allocated_bytes: allocated_bytes
+            )
+          end
         rescue
           # Allocation tracking might not be available in all Ruby versions
         end
@@ -36,29 +54,39 @@ module DeadBro
       # Never raise from instrumentation install
     end
 
+    # Current frame (top of stack) for nested job tracking; nil if none.
+    def self.current_events
+      stack = Thread.current[THREAD_LOCAL_KEY]
+      return nil unless stack.is_a?(Array) && stack.any?
+      stack.last
+    end
+
     def self.start_request_tracking
       # Only track if memory tracking is enabled
       return unless DeadBro.configuration.memory_tracking_enabled
 
-      Thread.current[THREAD_LOCAL_KEY] = {
+      frame = {
         allocations: [],
         memory_snapshots: [],
         large_objects: [],
+        request_allocations: nil,
         gc_before: gc_stats,
         memory_before: memory_usage_mb,
-        start_time: Time.now.utc.to_i,
+        start_time: Time.now.to_f,
         object_counts_before: count_objects_snapshot
       }
+      (Thread.current[THREAD_LOCAL_KEY] ||= []) << frame
     end
 
     def self.stop_request_tracking
-      events = Thread.current[THREAD_LOCAL_KEY]
-      Thread.current[THREAD_LOCAL_KEY] = nil
+      stack = Thread.current[THREAD_LOCAL_KEY]
+      events = stack.is_a?(Array) && stack.any? ? stack.pop : nil
+      Thread.current[THREAD_LOCAL_KEY] = nil if stack.nil? || stack.empty?
 
       if events
         events[:gc_after] = gc_stats
         events[:memory_after] = memory_usage_mb
-        events[:end_time] = Time.now.utc.to_i
+        events[:end_time] = Time.now.to_f
         events[:duration_seconds] = events[:end_time] - events[:start_time]
         events[:object_counts_after] = count_objects_snapshot
 
@@ -71,14 +99,26 @@ module DeadBro
       events || {}
     end
 
+    # Record request-level allocation counters from Rails instrumentation.
+    def self.record_request_allocations(allocations:, allocated_bytes:)
+      events = current_events
+      return unless events
+
+      events[:request_allocations] = {
+        allocations: allocations,
+        allocated_bytes: allocated_bytes
+      }
+    end
+
     def self.track_allocation(data, started, finished)
-      return unless Thread.current[THREAD_LOCAL_KEY]
+      events = current_events
+      return unless events
 
       # Only track if we have meaningful allocation data
       return unless data.is_a?(Hash) && data[:count] && data[:size]
 
       # Limit allocations per request to prevent memory bloat
-      allocations = Thread.current[THREAD_LOCAL_KEY][:allocations]
+      allocations = events[:allocations]
       return if allocations.length >= MAX_ALLOCATIONS_PER_REQUEST
 
       # Simplified allocation tracking (avoid expensive operations)
@@ -95,14 +135,15 @@ module DeadBro
           large_object: true,
           size_mb: (data[:size] / 1_000_000.0).round(2)
         )
-        Thread.current[THREAD_LOCAL_KEY][:large_objects] << large_object
+        events[:large_objects] << large_object
       end
 
-      Thread.current[THREAD_LOCAL_KEY][:allocations] << allocation
+      events[:allocations] << allocation
     end
 
     def self.take_memory_snapshot(label = nil)
-      return unless Thread.current[THREAD_LOCAL_KEY]
+      events = current_events
+      return unless events
 
       snapshot = {
         label: label || "snapshot_#{Time.now.to_i}",
@@ -113,7 +154,7 @@ module DeadBro
         heap_pages: heap_pages
       }
 
-      Thread.current[THREAD_LOCAL_KEY][:memory_snapshots] << snapshot
+      events[:memory_snapshots] << snapshot
     end
 
     def self.analyze_memory_performance(memory_events)
@@ -122,6 +163,7 @@ module DeadBro
       allocations = memory_events[:allocations] || []
       large_objects = memory_events[:large_objects] || []
       snapshots = memory_events[:memory_snapshots] || []
+      request_allocations = memory_events[:request_allocations]
 
       # Calculate memory growth
       memory_growth = 0
@@ -132,6 +174,19 @@ module DeadBro
       # Calculate allocation totals
       total_allocations = allocations.sum { |a| a[:count] }
       total_allocated_size = allocations.sum { |a| a[:size] }
+      if request_allocations
+        total_allocated_size = request_allocations[:allocated_bytes].to_i if total_allocated_size.zero?
+      end
+      gc_allocations = nil
+      if memory_events[:gc_before] && memory_events[:gc_after]
+        gc_allocations = (memory_events[:gc_after][:total_allocated_objects] || 0) -
+          (memory_events[:gc_before][:total_allocated_objects] || 0)
+      end
+      if gc_allocations.to_i > 0
+        total_allocations = gc_allocations
+      elsif total_allocations.zero? && request_allocations
+        total_allocations = request_allocations[:allocations].to_i
+      end
 
       # Group allocations by class
       allocations_by_class = allocations.group_by { |a| a[:class_name] }
@@ -174,7 +229,8 @@ module DeadBro
           (total_allocations.to_f / memory_events[:duration_seconds]).round(2) : 0,
         top_allocating_classes: top_allocating_classes.map { |class_name, data|
           {
-            class_name: class_name,
+            class: class_name,
+            name: class_name,
             count: data[:count],
             size: data[:size],
             size_mb: (data[:size] / 1_000_000.0).round(2)

data/lib/dead_bro/sql_subscriber.rb

@@ -16,13 +16,25 @@ module DeadBro
     THREAD_LOCAL_EXPLAIN_PENDING_KEY = :dead_bro_explain_pending
     MAX_TRACKED_QUERIES = 1000
 
+    # True when there is at least one active tracking context (e.g. for nested jobs).
+    def self.tracking_active?
+      stack = Thread.current[THREAD_LOCAL_KEY]
+      stack.is_a?(Array) && stack.any?
+    end
+
+    # Current queries array (top of stack); nil if no active tracking.
+    def self.current_queries_array
+      stack = Thread.current[THREAD_LOCAL_KEY]
+      return nil unless stack.is_a?(Array) && stack.any?
+      stack.last
+    end
+
     # Check if we should continue tracking based on count and time limits
-    def self.should_continue_tracking?(thread_local_key, max_count)
-      events = Thread.current[thread_local_key]
-      return false unless events
+    def self.should_continue_tracking?(current_queries_array, max_count)
+      return false unless current_queries_array.is_a?(Array)
 
       # Check count limit
-      return false if events.length >= max_count
+      return false if current_queries_array.length >= max_count
 
       # Check time limit
       start_time = Thread.current[DeadBro::TRACKING_START_TIME_KEY]
@@ -44,9 +56,10 @@ module DeadBro
       end
 
       ActiveSupport::Notifications.subscribe(SQL_EVENT_NAME) do |name, started, finished, _unique_id, data|
-        next if data[:name] == "SCHEMA"
-        # Only track queries that are part of the current request
-        next unless Thread.current[THREAD_LOCAL_KEY]
+        next if data[:name] == "SCHEMA" || data[:name] == "CACHE" || data[:name] == "BEGIN" || data[:name] == "COMMIT" || data[:name] == "ROLLBACK" || data[:name] == "SAVEPOINT" || data[:name] == "RELEASE"
+        # Only track queries that are part of the current request (top of stack for nested jobs)
+        current = current_queries_array
+        next unless current
         unique_id = _unique_id
         allocations = nil
         captured_backtrace = nil
@@ -82,15 +95,16 @@ module DeadBro
           start_explain_analyze_background(original_sql, data[:connection_id], query_info, binds)
         end
 
-        # Add to thread-local storage, but only if we haven't exceeded the limits
-        if should_continue_tracking?(THREAD_LOCAL_KEY, MAX_TRACKED_QUERIES)
-          Thread.current[THREAD_LOCAL_KEY] << query_info
+        # Add to current context (top of stack), but only if we haven't exceeded the limits
+        if should_continue_tracking?(current, MAX_TRACKED_QUERIES)
+          current << query_info
         end
       end
     end
 
     def self.start_request_tracking
-      Thread.current[THREAD_LOCAL_KEY] = []
+      # Stack allows nested job tracking (e.g. one job performing others in the same thread)
+      (Thread.current[THREAD_LOCAL_KEY] ||= []) << []
       Thread.current[THREAD_LOCAL_ALLOC_START_KEY] = {}
       Thread.current[THREAD_LOCAL_ALLOC_RESULTS_KEY] = {}
       Thread.current[THREAD_LOCAL_BACKTRACE_KEY] = {}
@@ -103,15 +117,17 @@ module DeadBro
       # all explain_plan fields are populated
       wait_for_pending_explains(5.0) # 5 second timeout
 
-      # Get queries after waiting for EXPLAIN to complete
-      queries = Thread.current[THREAD_LOCAL_KEY]
-
-      Thread.current[THREAD_LOCAL_KEY] = nil
-      Thread.current[THREAD_LOCAL_ALLOC_START_KEY] = nil
-      Thread.current[THREAD_LOCAL_ALLOC_RESULTS_KEY] = nil
-      Thread.current[THREAD_LOCAL_BACKTRACE_KEY] = nil
-      Thread.current[THREAD_LOCAL_EXPLAIN_PENDING_KEY] = nil
-      queries || []
+      stack = Thread.current[THREAD_LOCAL_KEY]
+      queries = stack.is_a?(Array) && stack.any? ? stack.pop : []
+      # Clear thread locals when stack is empty so "tracking not started" behaves correctly
+      if stack.nil? || stack.empty?
+        Thread.current[THREAD_LOCAL_KEY] = nil
+        Thread.current[THREAD_LOCAL_ALLOC_START_KEY] = nil
+        Thread.current[THREAD_LOCAL_ALLOC_RESULTS_KEY] = nil
+        Thread.current[THREAD_LOCAL_BACKTRACE_KEY] = nil
+        Thread.current[THREAD_LOCAL_EXPLAIN_PENDING_KEY] = nil
+      end
+      queries
     end
 
     def self.wait_for_pending_explains(timeout_seconds)

data/lib/dead_bro/version.rb

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

metadata

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