dead_bro 0.2.17 → 0.2.18

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0e9e839180ccf5281f99f831a4d437bdadd74a835c7e8f80fe321efb8bb1c9f7
-  data.tar.gz: c85de05b244a13bac3a2786624bd67f2f18d3b08c3ab3bcaa511857f8c276b90
+  metadata.gz: aa43ba99a6fb0fd4007b856a24ac5844236f2d0102f9ec71175c81981a91bb17
+  data.tar.gz: c91f7fee25858bafd2edabfb162239ea8d8833405a3b4965f55e403a06dbfd05
 SHA512:
-  metadata.gz: 87c69d57f3c712fc993663e4f8df46ad49ec584f0ccdd3f5f1a6c5eededbc8a9542f2b0d4cee446fb049288c5d7f086528fa91f1467aa778dea4cfd4b09302e4
-  data.tar.gz: 1aed3c8185b4b1f14b7707c97c9d38baa5cb19da9c268d7f6ae11024563e4f9452048a61fdbe616a6adadb4847559f1459a0c5b695306a31a0d579a66e2b5825
+  metadata.gz: b436b94d8d36d0b3407b09481326e443aa342c4398d4973fb517016bd3ee1f4a159a163d12a76b2294f2e4de36505b0cb568010bd8e0aecbbd0e3b4dc544069e
+  data.tar.gz: 7981b5ea511dad34ce67c0a71afe8a09f12045a0ae778311fa42ae0426f3a689d38377528939c6f757192bd973c3d3c782f9f2124831cfac5505d4bf1ab2d177

data/lib/dead_bro/sql_subscriber.rb

@@ -14,8 +14,18 @@ module DeadBro
     THREAD_LOCAL_ALLOC_RESULTS_KEY = :dead_bro_sql_alloc_results
     THREAD_LOCAL_BACKTRACE_KEY = :dead_bro_sql_backtraces
     THREAD_LOCAL_EXPLAIN_PENDING_KEY = :dead_bro_explain_pending
+    THREAD_LOCAL_CALL_COUNTS_KEY     = :dead_bro_sql_call_counts
+    THREAD_LOCAL_AGGREGATES_KEY      = :dead_bro_sql_aggregates
     MAX_TRACKED_QUERIES = 1000
 
+    # Number of identical queries within one request that triggers N+1 detection.
+    N_PLUS_ONE_THRESHOLD = 5
+
+    NORMALIZE_PARAM_RE   = /\$\d+/.freeze
+    NORMALIZE_NUMERIC_RE = /\b\d+(\.\d+)?\b/.freeze
+    NORMALIZE_IN_RE      = /\bIN\s*\([^)]+\)/i.freeze
+    NORMALIZE_SPACE_RE   = /\s+/.freeze
+
     # Precompiled regexes used by sanitize_sql. Dynamic /.../i literals inside
     # a hot-path method allocate a fresh Regexp on every call — pinning them
     # here removes that allocation entirely.
@@ -57,6 +67,20 @@ module DeadBro
       true
     end
 
+    def self.normalize_for_n_plus_one(sql)
+      return "" unless sql.is_a?(String)
+      s = sql.dup
+      s.gsub!(NORMALIZE_PARAM_RE, "?")
+      s.gsub!(NORMALIZE_NUMERIC_RE, "?")
+      s.gsub!(NORMALIZE_IN_RE, "IN (?)")
+      s.gsub!(NORMALIZE_SPACE_RE, " ")
+      s.strip!
+      s.downcase!
+      s
+    rescue
+      sql.to_s.downcase
+    end
+
     def self.subscribe!
       # Subscribe with a start/finish listener to measure allocations per query
       if ActiveSupport::Notifications.notifier.respond_to?(:subscribe)
@@ -82,19 +106,31 @@ module DeadBro
         duration_ms = ((finished - started) * 1000.0).round(2)
         original_sql = data[:sql]
 
-        # Only capture a backtrace for queries we actually care about tracing
-        # (slow). This skips the ~O(stack-depth) allocation on the 99% of queries
-        # that are fast. An N+1 of 100 x 1ms queries no longer eats a thousand
-        # frame allocations for traces nobody will read.
         threshold = begin
           DeadBro.configuration.slow_query_threshold_ms
         rescue
           500
         end
+        sanitized_sql  = sanitize_sql(original_sql)
         captured_trace = (duration_ms >= threshold.to_f) ? capture_app_backtrace : []
 
+        cc_stack     = Thread.current[THREAD_LOCAL_CALL_COUNTS_KEY]
+        agg_stack    = Thread.current[THREAD_LOCAL_AGGREGATES_KEY]
+        call_counts  = cc_stack.is_a?(Array)  ? cc_stack.last  : nil
+        aggregates_h = agg_stack.is_a?(Array) ? agg_stack.last : nil
+        normalized_key = nil
+
+        if call_counts && aggregates_h
+          normalized_key = normalize_for_n_plus_one(sanitized_sql)
+          call_counts[normalized_key] = (call_counts[normalized_key] || 0) + 1
+          # Capture backtrace exactly at the N+1 boundary — the stack is still meaningful here.
+          if call_counts[normalized_key] == N_PLUS_ONE_THRESHOLD && captured_trace.empty?
+            captured_trace = capture_app_backtrace
+          end
+        end
+
         query_info = {
-          sql: sanitize_sql(original_sql),
+          sql: sanitized_sql,
           name: data[:name],
           duration_ms: duration_ms,
           cached: data[:cached] || false,
@@ -103,16 +139,40 @@ module DeadBro
           allocations: allocations
         }
 
-        # Run EXPLAIN ANALYZE for slow queries in the background
         if should_explain_query?(duration_ms, original_sql)
-          # Store reference to query_info so we can update it when EXPLAIN completes
-          query_info[:explain_plan] = nil # Placeholder
-          # Capture binds if available (type_casted_binds is preferred as they are ready for quoting)
+          query_info[:explain_plan] = nil
           binds = data[:type_casted_binds] || data[:binds]
           start_explain_analyze_background(original_sql, data[:connection_id], query_info, binds)
         end
 
-        # Add to current context (top of stack), but only if we haven't exceeded the limits
+        if aggregates_h && normalized_key
+          call_count = call_counts[normalized_key]
+          if (agg = aggregates_h[normalized_key])
+            agg[:count]             += 1
+            agg[:total_duration_ms]  = (agg[:total_duration_ms] + duration_ms).round(2)
+            agg[:max_duration_ms]    = [agg[:max_duration_ms], duration_ms].max
+            agg[:min_duration_ms]    = [agg[:min_duration_ms], duration_ms].min
+            agg[:total_allocations] += (allocations || 0)
+            agg[:cached_count]      += 1 if query_info[:cached]
+            agg[:n_plus_one]         = true if call_count >= N_PLUS_ONE_THRESHOLD
+            agg[:backtrace]          = captured_trace if agg[:backtrace].empty? && !captured_trace.empty?
+          else
+            aggregates_h[normalized_key] = {
+              sql:               sanitized_sql,
+              name:              data[:name],
+              count:             1,
+              total_duration_ms: duration_ms,
+              max_duration_ms:   duration_ms,
+              min_duration_ms:   duration_ms,
+              total_allocations: allocations || 0,
+              cached_count:      (data[:cached] ? 1 : 0),
+              n_plus_one:        false,
+              backtrace:         captured_trace,
+              explain_plan:      nil
+            }
+          end
+        end
+
         if should_continue_tracking?(current, MAX_TRACKED_QUERIES)
           current << query_info
         end
@@ -126,25 +186,40 @@ module DeadBro
       Thread.current[THREAD_LOCAL_ALLOC_RESULTS_KEY] = {}
       Thread.current[THREAD_LOCAL_BACKTRACE_KEY] = {}
       Thread.current[THREAD_LOCAL_EXPLAIN_PENDING_KEY] = []
+      (Thread.current[THREAD_LOCAL_CALL_COUNTS_KEY] ||= []) << {}
+      (Thread.current[THREAD_LOCAL_AGGREGATES_KEY]  ||= []) << {}
     end
 
     def self.stop_request_tracking
-      # Wait for any pending EXPLAIN ANALYZE queries to complete (with timeout)
-      # This must happen BEFORE we get the queries array reference to ensure
-      # all explain_plan fields are populated
       wait_for_pending_explains(EXPLAIN_WAIT_TIMEOUT_SECONDS)
 
       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
+      raw_queries = (stack.is_a?(Array) && stack.any?) ? stack.pop : []
+
+      agg_stack    = Thread.current[THREAD_LOCAL_AGGREGATES_KEY]
+      aggregates_h = (agg_stack.is_a?(Array) && agg_stack.any?) ? agg_stack.pop : {}
+      cc_stack     = Thread.current[THREAD_LOCAL_CALL_COUNTS_KEY]
+      cc_stack.pop if cc_stack.is_a?(Array) && cc_stack.any?
+
+      # Fold any completed EXPLAIN plans from raw queries into their aggregate entry
+      raw_queries.each do |q|
+        next unless q[:explain_plan]
+        key = normalize_for_n_plus_one(q[:sql].to_s)
+        agg = aggregates_h[key]
+        agg[:explain_plan] ||= q[:explain_plan] if agg
+      end
+
       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
+        Thread.current[THREAD_LOCAL_CALL_COUNTS_KEY] = nil
+        Thread.current[THREAD_LOCAL_AGGREGATES_KEY]  = nil
       end
-      queries
+
+      aggregates_h.values.sort_by { |a| -a[:total_duration_ms] }
     end
 
     # Upper bound on pending EXPLAIN threads per request — stops a slow-query

data/lib/dead_bro/version.rb

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

data/lib/dead_bro/view_rendering_subscriber.rb

@@ -4,167 +4,147 @@ require "active_support/notifications"
 
 module DeadBro
   class ViewRenderingSubscriber
-    # Rails view rendering events
-    RENDER_TEMPLATE_EVENT = "render_template.action_view"
-    RENDER_PARTIAL_EVENT = "render_partial.action_view"
+    RENDER_TEMPLATE_EVENT  = "render_template.action_view"
+    RENDER_PARTIAL_EVENT   = "render_partial.action_view"
     RENDER_COLLECTION_EVENT = "render_collection.action_view"
 
-    THREAD_LOCAL_KEY = :dead_bro_view_events
-    MAX_TRACKED_EVENTS = 1000
+    THREAD_LOCAL_KEY            = :dead_bro_view_events
+    THREAD_LOCAL_AGGREGATES_KEY = :dead_bro_view_aggregates
+    MAX_TRACKED_EVENTS = 500
 
     def self.subscribe!(client: Client.new)
-      # Track template rendering
-      ActiveSupport::Notifications.subscribe(RENDER_TEMPLATE_EVENT) do |name, started, finished, _unique_id, data|
-        duration_ms = ((finished - started) * 1000.0).round(2)
-
-        view_info = {
-          type: "template",
-          identifier: safe_identifier(data[:identifier]),
-          layout: data[:layout],
-          duration_ms: duration_ms,
-          virtual_path: data[:virtual_path],
-          rendered_at: Time.now.utc.to_i
-        }
-
-        add_view_event(view_info)
+      ActiveSupport::Notifications.subscribe(RENDER_TEMPLATE_EVENT) do |_name, started, finished, _uid, data|
+        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)
       end
 
-      # Track partial rendering
-      ActiveSupport::Notifications.subscribe(RENDER_PARTIAL_EVENT) do |name, started, finished, _unique_id, data|
-        duration_ms = ((finished - started) * 1000.0).round(2)
-
-        view_info = {
-          type: "partial",
-          identifier: safe_identifier(data[:identifier]),
-          layout: data[:layout],
-          duration_ms: duration_ms,
-          virtual_path: data[:virtual_path],
-          cache_key: data[:cache_key],
-          rendered_at: Time.now.utc.to_i
-        }
-
-        add_view_event(view_info)
+      ActiveSupport::Notifications.subscribe(RENDER_PARTIAL_EVENT) do |_name, started, finished, _uid, data|
+        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)
       end
 
-      # Track collection rendering (for partials rendered in loops)
-      ActiveSupport::Notifications.subscribe(RENDER_COLLECTION_EVENT) do |name, started, finished, _unique_id, data|
-        duration_ms = ((finished - started) * 1000.0).round(2)
-
-        view_info = {
-          type: "collection",
-          identifier: safe_identifier(data[:identifier]),
-          layout: data[:layout],
-          duration_ms: duration_ms,
-          virtual_path: data[:virtual_path],
-          cache_key: data[:cache_key],
-          count: data[:count],
-          cached_count: data[:cached_count],
-          rendered_at: Time.now.utc.to_i
-        }
-
-        add_view_event(view_info)
+      ActiveSupport::Notifications.subscribe(RENDER_COLLECTION_EVENT) do |_name, started, finished, _uid, data|
+        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)
       end
     rescue
-      # Never raise from instrumentation install
     end
 
     def self.start_request_tracking
-      Thread.current[THREAD_LOCAL_KEY] = []
+      Thread.current[THREAD_LOCAL_KEY]            = true
+      Thread.current[THREAD_LOCAL_AGGREGATES_KEY] = {}
     end
 
     def self.stop_request_tracking
-      events = Thread.current[THREAD_LOCAL_KEY]
       Thread.current[THREAD_LOCAL_KEY] = nil
-      events || []
+      aggregates = Thread.current[THREAD_LOCAL_AGGREGATES_KEY] || {}
+      Thread.current[THREAD_LOCAL_AGGREGATES_KEY] = nil
+      aggregates.values.sort_by { |a| [-a[:count], -a[:total_duration_ms]] }
     end
 
     def self.add_view_event(view_info)
-      if Thread.current[THREAD_LOCAL_KEY] && should_continue_tracking?
-        Thread.current[THREAD_LOCAL_KEY] << view_info
+      return unless Thread.current[THREAD_LOCAL_KEY]
+      aggregates = Thread.current[THREAD_LOCAL_AGGREGATES_KEY]
+      return unless aggregates
+
+      key = view_info[:identifier].to_s
+      dur = view_info[:duration_ms].to_f
+      rendered_at = view_info[:rendered_at]
+
+      if (agg = aggregates[key])
+        agg[:count]                   += 1
+        agg[:total_duration_ms]        = (agg[:total_duration_ms] + dur).round(2)
+        agg[:max_duration_ms]          = [agg[:max_duration_ms], dur].max
+        agg[:min_duration_ms]          = [agg[:min_duration_ms], dur].min
+        agg[:rendered_at_min]          = [agg[:rendered_at_min], rendered_at].compact.min if rendered_at
+        agg[:rendered_at_max]          = [agg[:rendered_at_max], rendered_at].compact.max if rendered_at
+        agg[:cache_hit_count]         += 1 if view_info[:cache_key]
+        agg[:collection_count]        += view_info[:collection_count].to_i
+        agg[:collection_cached_count] += view_info[:collection_cached_count].to_i
+      else
+        return if aggregates.size >= MAX_TRACKED_EVENTS
+        aggregates[key] = {
+          identifier:              key,
+          type:                    view_info[:type],
+          count:                   1,
+          total_duration_ms:       dur,
+          max_duration_ms:         dur,
+          min_duration_ms:         dur,
+          rendered_at_min:         rendered_at,
+          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
+        }
       end
     end
 
-    # Check if we should continue tracking based on count and time limits
-    def self.should_continue_tracking?
-      events = Thread.current[THREAD_LOCAL_KEY]
-      return false unless events
-
-      # Check count limit
-      return false if events.length >= MAX_TRACKED_EVENTS
-
-      # Check time limit
-      start_time = Thread.current[DeadBro::TRACKING_START_TIME_KEY]
-      if start_time
-        elapsed_seconds = Time.now - start_time
-        return false if elapsed_seconds >= DeadBro::MAX_TRACKING_DURATION_SECONDS
-      end
-
-      true
-    end
-
     def self.safe_identifier(identifier)
       return "" unless identifier.is_a?(String)
-
-      # Extract meaningful parts of the file path
-      # e.g., "/app/views/users/show.html.erb" -> "users/show.html.erb"
       identifier.split("/").last(3).join("/")
     rescue
       identifier.to_s
     end
 
-    # Analyze view rendering performance
     def self.analyze_view_performance(view_events)
       return {} if view_events.empty?
 
-      total_duration = view_events.sum { |event| event[:duration_ms] }
+      total_renders  = view_events.sum { |e| e_int(e, :count, 1) }
+      total_duration = view_events.sum { |e| e_flt(e, :total_duration_ms) }
 
-      # Group by view type
-      by_type = view_events.group_by { |event| event[:type] }
+      by_type = Hash.new(0)
+      view_events.each { |e| by_type[e_str(e, :type)] += e_int(e, :count, 1) }
 
-      # Find slowest views
-      slowest_views = view_events.sort_by { |event| -event[:duration_ms] }.first(5)
+      slowest = view_events.sort_by { |e| -e_flt(e, :max_duration_ms) }.first(5).map do |e|
+        { identifier: e_str(e, :identifier), duration_ms: e_flt(e, :max_duration_ms), type: e_str(e, :type) }
+      end
 
-      # Find most frequently rendered views
-      view_frequency = view_events.group_by { |event| event[:identifier] }
-        .transform_values(&:count)
-        .sort_by { |_, count| -count }
-        .first(5)
+      most_frequent = view_events.sort_by { |e| -e_int(e, :count, 1) }.first(5).map do |e|
+        { identifier: e_str(e, :identifier), count: e_int(e, :count, 1) }
+      end
 
-      # Calculate cache hit rates for partials
-      partials = view_events.select { |event| event[:type] == "partial" }
-      cache_hits = partials.count { |event| event[:cache_key] }
-      cache_hit_rate = partials.any? ? (cache_hits.to_f / partials.count * 100).round(2) : 0
+      partials                = view_events.select { |e| e_str(e, :type) == "partial" }
+      total_partial_renders   = partials.sum { |e| e_int(e, :count, 1) }
+      total_cache_hits        = partials.sum { |e| e_int(e, :cache_hit_count) }
+      partial_cache_hit_rate  = total_partial_renders > 0 ? (total_cache_hits.to_f / total_partial_renders * 100).round(2) : 0
 
-      # Collection rendering analysis
-      collections = view_events.select { |event| event[:type] == "collection" }
-      total_collection_items = collections.sum { |event| event[:count] || 0 }
-      total_cached_items = collections.sum { |event| event[:cached_count] || 0 }
-      collection_cache_hit_rate = (total_collection_items > 0) ?
-        (total_cached_items.to_f / total_collection_items * 100).round(2) : 0
+      collections            = view_events.select { |e| e_str(e, :type) == "collection" }
+      total_collection_items = collections.sum { |e| e_int(e, :collection_count) }
+      total_cached_items     = collections.sum { |e| e_int(e, :collection_cached_count) }
+      collection_cache_hit_rate = total_collection_items > 0 ? (total_cached_items.to_f / total_collection_items * 100).round(2) : 0
 
       {
-        total_views_rendered: view_events.count,
-        total_view_duration_ms: total_duration.round(2),
-        average_view_duration_ms: (total_duration / view_events.count).round(2),
-        by_type: by_type.transform_values(&:count),
-        slowest_views: slowest_views.map { |view|
-          {
-            identifier: view[:identifier],
-            duration_ms: view[:duration_ms],
-            type: view[:type]
-          }
-        },
-        most_frequent_views: view_frequency.map { |identifier, count|
-          {
-            identifier: identifier,
-            count: count
-          }
-        },
-        partial_cache_hit_rate: cache_hit_rate,
-        collection_cache_hit_rate: collection_cache_hit_rate,
-        total_collection_items: total_collection_items,
-        total_cached_collection_items: total_cached_items
+        total_views_rendered:           total_renders,
+        total_view_duration_ms:         total_duration.round(2),
+        average_view_duration_ms:       total_renders > 0 ? (total_duration / total_renders).round(2) : 0,
+        by_type:                        by_type,
+        slowest_views:                  slowest,
+        most_frequent_views:            most_frequent,
+        partial_cache_hit_rate:         partial_cache_hit_rate,
+        collection_cache_hit_rate:      collection_cache_hit_rate,
+        total_collection_items:         total_collection_items,
+        total_cached_collection_items:  total_cached_items
       }
     end
+
+    private
+
+    def self.e_int(e, key, default = 0)
+      (e[key] || e[key.to_s] || default).to_i
+    end
+
+    def self.e_flt(e, key, default = 0.0)
+      (e[key] || e[key.to_s] || default).to_f
+    end
+
+    def self.e_str(e, key, default = "")
+      (e[key] || e[key.to_s] || default).to_s
+    end
   end
 end

metadata

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