dead_bro 0.2.6 → 0.2.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7e977f41766dfbcf7ca52cf14aafb217595f35860746a553bd9386b1ddfe7797
-  data.tar.gz: 24858e179f45181d6d144352347ed3f760a19abe53cead83c80eb4644e281f39
+  metadata.gz: 9a78b3a99d00159acb1bf2fd97a0eed54ba0e03a24d7bbd2ec840e4bf779107f
+  data.tar.gz: 53aba3dcf00e53f210020529413561812de25b3399db8ce040b9976ab798e8d1
 SHA512:
-  metadata.gz: 7310571657927f6404088b2605d710cb9e107d5e63231cddcf785ffc9cc22a78ff634d5bc5969e34d08e634ed0cdc46f85f8f2d6937bc05ebe9af14b00c4968c
-  data.tar.gz: eaaec05db2cdf1d2da03cfa873c333286d891e33cb2e37d6b347b319a3ae8481f142182d87c3ce20bd2990829075aa236e52c9f52388d2799fc862b1511ceabd
+  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

@@ -54,11 +54,18 @@ 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: [],
@@ -68,11 +75,13 @@ module DeadBro
         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
@@ -92,22 +101,24 @@ module DeadBro
 
     # Record request-level allocation counters from Rails instrumentation.
     def self.record_request_allocations(allocations:, allocated_bytes:)
-      return unless Thread.current[THREAD_LOCAL_KEY]
+      events = current_events
+      return unless events
 
-      Thread.current[THREAD_LOCAL_KEY][:request_allocations] = {
+      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)
@@ -124,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}",
@@ -142,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)

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.6"
+  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.6
+  version: 0.2.7
 platform: ruby
 authors:
 - Emanuel Comsa