dead_bro 0.2.7 → 0.2.9

data/lib/dead_bro/redis_subscriber.rb

@@ -25,8 +25,8 @@ module DeadBro
     def self.install_redis_client!
       # Only instrument if Redis::Client actually has the call method
       # Check both public and private methods
-      has_call = ::Redis::Client.instance_methods(false).include?(:call) ||
-        ::Redis::Client.private_instance_methods(false).include?(:call)
+      has_call = ::Redis::Client.method_defined?(:call, false) ||
+        ::Redis::Client.private_method_defined?(:call, false)
       return unless has_call
 
       mod = Module.new do

data/lib/dead_bro/sql_subscriber.rb

@@ -16,6 +16,17 @@ module DeadBro
     THREAD_LOCAL_EXPLAIN_PENDING_KEY = :dead_bro_explain_pending
     MAX_TRACKED_QUERIES = 1000
 
+    # 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.
+    SENSITIVE_KV_QUOTED_RE = /\b(password|token|secret|key|ssn|credit_card)\s*=\s*['"][^'"]*['"]/i
+    SENSITIVE_KV_BARE_RE   = /\b(password|token|secret|key|ssn|credit_card)\s*=\s*[^'",\s)]+/i
+    WHERE_EQ_QUOTED_RE     = /WHERE\s+[^=]+=\s*['"][^'"]*['"]/i
+    WHERE_EQ_QUOTED_INNER_RE = /=\s*['"][^'"]*['"]/
+    SANITIZE_MAX_LENGTH    = 1000
+    SANITIZE_SKIP_SENSITIVE_WHEN_NO_KEYWORDS = /password|token|secret|key|ssn|credit_card/i
+    SANITIZE_SKIP_WHERE_WHEN_NO_KEYWORD = /WHERE/i
+
     # 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]
@@ -62,27 +73,33 @@ module DeadBro
         next unless current
         unique_id = _unique_id
         allocations = nil
-        captured_backtrace = nil
         begin
           alloc_results = Thread.current[THREAD_LOCAL_ALLOC_RESULTS_KEY]
           allocations = alloc_results && alloc_results.delete(unique_id)
-
-          # Get the captured backtrace from when the query started
-          backtrace_map = Thread.current[THREAD_LOCAL_BACKTRACE_KEY]
-          captured_backtrace = backtrace_map && backtrace_map.delete(unique_id)
         rescue
         end
 
         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
+        captured_trace = (duration_ms >= threshold.to_f) ? capture_app_backtrace : []
+
         query_info = {
           sql: sanitize_sql(original_sql),
           name: data[:name],
           duration_ms: duration_ms,
           cached: data[:cached] || false,
           connection_id: data[:connection_id],
-          trace: safe_query_trace(data, captured_backtrace),
+          trace: captured_trace,
           allocations: allocations
         }
 
@@ -115,10 +132,10 @@ module DeadBro
       # 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(5.0) # 5 second timeout
+      wait_for_pending_explains(EXPLAIN_WAIT_TIMEOUT_SECONDS)
 
       stack = Thread.current[THREAD_LOCAL_KEY]
-      queries = stack.is_a?(Array) && stack.any? ? stack.pop : []
+      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
@@ -130,13 +147,21 @@ module DeadBro
       queries
     end
 
+    # Upper bound on pending EXPLAIN threads per request — stops a slow-query
+    # storm from spawning unbounded background threads.
+    MAX_PENDING_EXPLAINS = 20
+    # Overall wall-clock we're willing to block the request thread for pending
+    # EXPLAINs. Dropped from 5s → 1s: if the plan isn't ready by then, skip it
+    # rather than stall the request.
+    EXPLAIN_WAIT_TIMEOUT_SECONDS = 1.0
+
     def self.wait_for_pending_explains(timeout_seconds)
       pending = Thread.current[THREAD_LOCAL_EXPLAIN_PENDING_KEY]
       return unless pending && !pending.empty?
 
-      start_time = Time.now
+      start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
       pending.each do |thread|
-        remaining_time = timeout_seconds - (Time.now - start_time)
+        remaining_time = timeout_seconds - (Process.clock_gettime(Process::CLOCK_MONOTONIC) - start_time)
         break if remaining_time <= 0
 
         begin
@@ -150,17 +175,26 @@ module DeadBro
     def self.sanitize_sql(sql)
       return sql unless sql.is_a?(String)
 
-      # Remove sensitive data patterns
-      sql = sql.gsub(/\b(password|token|secret|key|ssn|credit_card)\s*=\s*['"][^'"]*['"]/i, '\1 = ?')
-      sql = sql.gsub(/\b(password|token|secret|key|ssn|credit_card)\s*=\s*[^'",\s)]+/i, '\1 = ?')
+      # Cap length first — most "expensive" queries from the app's perspective
+      # are big UPDATE/INSERT with long literal blobs; don't burn regex time on
+      # those when we're going to truncate anyway.
+      sql = sql[0..SANITIZE_MAX_LENGTH] + "..." if sql.length > SANITIZE_MAX_LENGTH
+
+      # Only scan for sensitive KV pairs if one of the keywords is actually
+      # present — saves two regex passes on the vast majority of queries.
+      if sql.match?(SANITIZE_SKIP_SENSITIVE_WHEN_NO_KEYWORDS)
+        sql = sql.gsub(SENSITIVE_KV_QUOTED_RE, '\1 = ?')
+        sql = sql.gsub(SENSITIVE_KV_BARE_RE, '\1 = ?')
+      end
 
-      # Remove specific values in WHERE clauses that might be sensitive
-      sql = sql.gsub(/WHERE\s+[^=]+=\s*['"][^'"]*['"]/i) do |match|
-        match.gsub(/=\s*['"][^'"]*['"]/, "= ?")
+      # Same short-circuit for WHERE rewrite.
+      if sql.match?(SANITIZE_SKIP_WHERE_WHEN_NO_KEYWORD)
+        sql = sql.gsub(WHERE_EQ_QUOTED_RE) do |match|
+          match.gsub(WHERE_EQ_QUOTED_INNER_RE, "= ?")
+        end
       end
 
-      # Limit query length to prevent huge payloads
-      (sql.length > 1000) ? sql[0..1000] + "..." : sql
+      sql
     end
 
     def self.should_explain_query?(duration_ms, sql)
@@ -185,64 +219,47 @@ module DeadBro
       return unless defined?(ActiveRecord)
       return unless ActiveRecord::Base.respond_to?(:connection)
 
+      # Cap pending EXPLAINs per request. A slow-query storm that would have
+      # spawned 200 threads and starved the AR pool now drops excess plans
+      # instead of cascading into a timeout.
+      pending = Thread.current[THREAD_LOCAL_EXPLAIN_PENDING_KEY] ||= []
+      if pending.length >= MAX_PENDING_EXPLAINS
+        query_info[:explain_plan] = nil
+        return
+      end
+
       # Capture the main thread reference to append logs to the correct thread
       main_thread = Thread.current
 
-      # Run EXPLAIN in a background thread to avoid blocking the main request
+      # Run EXPLAIN in a background thread to avoid blocking the main request.
+      # We use `with_connection` so the connection returns to the pool even if
+      # the thread is killed or the block raises — the previous manual
+      # checkout/checkin could leak a connection under pathological paths.
       explain_thread = Thread.new do
-        connection = nil
         begin
-          # Use a separate connection to avoid interfering with the main query
-          connection = if ActiveRecord::Base.connection_pool.respond_to?(:checkout)
-            ActiveRecord::Base.connection_pool.checkout
-          else
-            ActiveRecord::Base.connection
-          end
-
-          # Interpolate binds if present to ensure EXPLAIN works with placeholders
-          final_sql = interpolate_sql_with_binds(sql, binds, connection)
-
-          # Build EXPLAIN query based on database adapter
-          explain_sql = build_explain_query(final_sql, connection)
+          ActiveRecord::Base.connection_pool.with_connection do |connection|
+            final_sql = interpolate_sql_with_binds(sql, binds, connection)
+            explain_sql = build_explain_query(final_sql, connection)
 
-          # Execute the EXPLAIN query
-          # For PostgreSQL, use select_all which returns ActiveRecord::Result
-          # For other databases, use execute
-          adapter_name = connection.adapter_name.downcase
-          result = if adapter_name == "postgresql" || adapter_name == "postgis"
-            # PostgreSQL: select_all returns ActiveRecord::Result with rows
-            connection.select_all(explain_sql)
-          else
-            # Other databases: use execute
-            connection.execute(explain_sql)
-          end
-
-          # Format the result based on database adapter
-          explain_plan = format_explain_result(result, connection)
+            adapter_name = connection.adapter_name.downcase
+            result = if adapter_name == "postgresql" || adapter_name == "postgis"
+              connection.select_all(explain_sql)
+            else
+              connection.execute(explain_sql)
+            end
 
-          # Update the query_info with the explain plan
-          # This updates the hash that's already in the queries array
-          query_info[:explain_plan] = if explain_plan && !explain_plan.to_s.strip.empty?
-            explain_plan
+            explain_plan = format_explain_result(result, connection)
+            query_info[:explain_plan] = if explain_plan && !explain_plan.to_s.strip.empty?
+              explain_plan
+            end
           end
         rescue => e
-          # Silently fail - don't let EXPLAIN break the application
+          # Silently fail — don't let EXPLAIN break the application.
           append_log_to_thread(main_thread, :debug, "Failed to capture EXPLAIN ANALYZE: #{e.message}")
           query_info[:explain_plan] = nil
-        ensure
-          # Return connection to pool if we checked it out
-          if connection && ActiveRecord::Base.connection_pool.respond_to?(:checkin)
-            begin
-              ActiveRecord::Base.connection_pool.checkin(connection)
-            rescue
-              nil
-            end
-          end
         end
       end
 
-      # Track the thread so we can wait for it when stopping request tracking
-      pending = Thread.current[THREAD_LOCAL_EXPLAIN_PENDING_KEY] ||= []
       pending << explain_thread
     rescue => e
       # Use DeadBro.logger here since we're still in the main thread
@@ -419,6 +436,27 @@ module DeadBro
       result.to_s
     end
 
+    APP_BACKTRACE_MAX_FRAMES = 25
+    APP_BACKTRACE_SENSITIVE_RE = /\/[^\/]*(password|secret|key|token)[^\/]*\//i
+
+    # Cheap app-only backtrace for the current query. Uses caller_locations
+    # (lazy frame objects, no string allocations until we render) and keeps
+    # only frames under app/ (filtering vendor/). Returns at most N frames.
+    def self.capture_app_backtrace
+      locations = caller_locations(1, 100) || []
+      frames = []
+      locations.each do |loc|
+        path = loc.path.to_s
+        next unless path.include?("app/")
+        next if path.include?("/vendor/")
+        frames << "#{path}:#{loc.lineno}:in `#{loc.label}'".gsub(APP_BACKTRACE_SENSITIVE_RE, "/[FILTERED]/")
+        break if frames.length >= APP_BACKTRACE_MAX_FRAMES
+      end
+      frames
+    rescue
+      []
+    end
+
     def self.safe_query_trace(data, captured_backtrace = nil)
       return [] unless data.is_a?(Hash)
 
@@ -520,15 +558,10 @@ module DeadBro
     def start(name, id, payload)
       map = (Thread.current[DeadBro::SqlSubscriber::THREAD_LOCAL_ALLOC_START_KEY] ||= {})
       map[id] = GC.stat[:total_allocated_objects] if defined?(GC) && GC.respond_to?(:stat)
-
-      # Capture the backtrace at query start time (before notification system processes it)
-      # This gives us the actual call stack where the SQL was executed
-      backtrace_map = (Thread.current[DeadBro::SqlSubscriber::THREAD_LOCAL_BACKTRACE_KEY] ||= {})
-      captured_backtrace = Thread.current.backtrace
-      if captured_backtrace && captured_backtrace.is_a?(Array)
-        # Skip the first few frames (our listener code) to get to the actual query execution
-        backtrace_map[id] = captured_backtrace[5..-1] || captured_backtrace
-      end
+      # Backtraces used to be captured here for every SQL event, which was
+      # dominating CPU on N+1-heavy requests (100s of full Thread#backtrace
+      # allocations). The main subscriber now captures a trimmed backtrace
+      # lazily — and only when a query exceeds slow_query_threshold_ms.
     rescue
     end
 

data/lib/dead_bro/subscriber.rb

@@ -8,21 +8,38 @@ module DeadBro
 
     def self.subscribe!(client: Client.new)
       ActiveSupport::Notifications.subscribe(EVENT_NAME) do |name, started, finished, _unique_id, data|
+        # When disabled remotely, fire a heartbeat at most once per minute so the gem
+        # can detect when tracking has been re-enabled, then skip all tracking.
+        unless DeadBro.configuration.enabled
+          client.post_heartbeat if DeadBro.configuration.heartbeat_due?
+          drain_request_tracking
+          next
+        end
+
         # Skip excluded controllers or controller#action pairs
         # Also check exclusive_controller_actions - if defined, only track those
+        notification = data.is_a?(Hash) ? data : {}
+        controller_name = notification[:controller].to_s
+        action_name = notification[:action].to_s
         begin
-          controller_name = data[:controller].to_s
-          action_name = data[:action].to_s
           if DeadBro.configuration.excluded_controller?(controller_name, action_name)
-            puts "excluded controller"
+            drain_request_tracking
             next
           end
-          # If exclusive_controller_actions is defined and not empty, only track matching actions
           unless DeadBro.configuration.exclusive_controller?(controller_name, action_name)
-            puts "exclusive controller"
+            drain_request_tracking
             next
           end
         rescue
+          drain_request_tracking
+          next
+        end
+
+        has_error = data[:exception] || data[:exception_object]
+        # Errors always ship regardless of sampling (this is what the docs promise).
+        unless has_error || DeadBro.configuration.should_sample?
+          drain_request_tracking
+          next
         end
 
         duration_ms = ((finished - started) * 1000.0).round(2)
@@ -106,7 +123,7 @@ module DeadBro
             }
 
             event_name = (exception_class || exception_obj&.class&.name || "exception").to_s
-            client.post_metric(event_name: event_name, payload: error_payload)
+            client.post_metric(event_name: event_name, payload: error_payload, force: true)
           rescue
           ensure
             next
@@ -147,6 +164,23 @@ module DeadBro
       end
     end
 
+    # Release per-subscriber thread-local state when we've decided not to build
+    # a payload (disabled / excluded / sampled out). Without this, a subsequent
+    # request reusing the same Puma thread would see stale queries/events.
+    def self.drain_request_tracking
+      DeadBro::SqlSubscriber.stop_request_tracking if defined?(DeadBro::SqlSubscriber)
+      DeadBro::CacheSubscriber.stop_request_tracking if defined?(DeadBro::CacheSubscriber)
+      DeadBro::RedisSubscriber.stop_request_tracking if defined?(DeadBro::RedisSubscriber)
+      DeadBro::ViewRenderingSubscriber.stop_request_tracking if defined?(DeadBro::ViewRenderingSubscriber)
+      DeadBro::LightweightMemoryTracker.stop_request_tracking if defined?(DeadBro::LightweightMemoryTracker)
+      if DeadBro.configuration.allocation_tracking_enabled && defined?(DeadBro::MemoryTrackingSubscriber)
+        DeadBro::MemoryTrackingSubscriber.stop_request_tracking
+      end
+      Thread.current[:dead_bro_http_events] = nil
+    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
@@ -259,17 +293,7 @@ module DeadBro
     end
 
     def self.memory_usage_mb
-      if defined?(GC) && GC.respond_to?(:stat)
-        # Get memory usage in MB
-        memory_kb = begin
-          `ps -o rss= -p #{Process.pid}`.to_i
-        rescue
-          0
-        end
-        (memory_kb / 1024.0).round(2)
-      else
-        0
-      end
+      DeadBro::MemoryHelpers.rss_mb
     rescue
       0
     end

data/lib/dead_bro/version.rb

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

data/lib/dead_bro.rb

@@ -5,6 +5,7 @@ require_relative "dead_bro/version"
 module DeadBro
   autoload :Configuration, "dead_bro/configuration"
   autoload :Client, "dead_bro/client"
+  autoload :Dispatcher, "dead_bro/dispatcher"
   autoload :CircuitBreaker, "dead_bro/circuit_breaker"
   autoload :Collectors, "dead_bro/collectors"
   autoload :Subscriber, "dead_bro/subscriber"
@@ -20,6 +21,7 @@ module DeadBro
   autoload :JobSubscriber, "dead_bro/job_subscriber"
   autoload :JobSqlTrackingMiddleware, "dead_bro/job_sql_tracking_middleware"
   autoload :Monitor, "dead_bro/monitor"
+  autoload :MemoryDetails, "dead_bro/memory_details"
   autoload :Logger, "dead_bro/logger"
   begin
     require "dead_bro/railtie"
@@ -110,33 +112,39 @@ module DeadBro
   # - :memory_after_mb
   # - :memory_delta_mb
   # - :memory_details (detailed GC/allocation stats when available)
-  def self.analyze(label = nil)
+  def self.analyze(label = nil, verbose: false)
     raise ArgumentError, "DeadBro.analyze requires a block" unless block_given?
 
     label ||= "block"
 
-    memory_tracking_started = false
-    memory_before_mb = 0.0
-
-    begin
-      if defined?(DeadBro::MemoryTrackingSubscriber) &&
-         !Thread.current[DeadBro::MemoryTrackingSubscriber::THREAD_LOCAL_KEY]
-        DeadBro::MemoryTrackingSubscriber.start_request_tracking
-        memory_tracking_started = true
+    # Lower Rails log level to DEBUG and enable ActiveRecord verbose_query_logs
+    # so Rails' own SQL logging (including ↳ caller frames) is visible.
+    original_log_level = nil
+    original_verbose_query_logs = nil
+    if verbose
+      begin
+        if defined?(Rails) && Rails.respond_to?(:logger) && Rails.logger.respond_to?(:level)
+          original_log_level = Rails.logger.level
+          Rails.logger.level = 0 # Logger::DEBUG
+        end
+      rescue
       end
-    rescue
-    end
-
-    begin
-      if defined?(DeadBro::MemoryTrackingSubscriber)
-        memory_before_mb = DeadBro::MemoryTrackingSubscriber.memory_usage_mb
-      else
-        memory_before_mb = 0.0
+      begin
+        if defined?(ActiveRecord) && ActiveRecord.respond_to?(:verbose_query_logs)
+          original_verbose_query_logs = ActiveRecord.verbose_query_logs
+          ActiveRecord.verbose_query_logs = true
+        end
+      rescue
       end
-    rescue
-      memory_before_mb = 0.0
     end
 
+    # Capture baseline memory stats — config-independent, analyze is debug-only.
+    gc_before = begin; GC.stat; rescue; {}; end
+    memory_before_mb = begin; DeadBro::MemoryHelpers.rss_mb; rescue; 0.0; end
+    object_counts_before = begin
+      defined?(ObjectSpace) && ObjectSpace.respond_to?(:count_objects) ? ObjectSpace.count_objects.dup : {}
+    rescue; {}; end
+
     # Local SQL tracking just for this block.
     # We subscribe directly to ActiveSupport::Notifications instead of relying
     # on DeadBro's global SqlSubscriber tracking so we don't interfere with or
@@ -148,7 +156,6 @@ module DeadBro
     begin
       if defined?(ActiveSupport) && defined?(ActiveSupport::Notifications)
         # Ensure SqlSubscriber is loaded so SQL_EVENT_NAME is defined
-        DeadBro::SqlSubscriber
         event_name = DeadBro::SqlSubscriber::SQL_EVENT_NAME
 
         sql_notification_subscription =
@@ -183,11 +190,7 @@ module DeadBro
               "SQL"
             end
 
-            local_sql_queries << {
-              duration_ms: duration_ms,
-              sql: normalized_sql,
-              query_type: query_type
-            }
+            local_sql_queries << {duration_ms: duration_ms, sql: normalized_sql, query_type: query_type}
           end
       end
     rescue
@@ -197,14 +200,26 @@ module DeadBro
     block_start = Process.clock_gettime(Process::CLOCK_MONOTONIC)
 
     error = nil
-    result = nil
-    analysis_result = nil
 
     begin
-      result = yield
+      yield
     rescue => e
       error = e
     ensure
+      # Restore Rails log level before any output
+      begin
+        if verbose && original_log_level
+          Rails.logger.level = original_log_level
+        end
+      rescue
+      end
+      begin
+        if verbose && !original_verbose_query_logs.nil?
+          ActiveRecord.verbose_query_logs = original_verbose_query_logs
+        end
+      rescue
+      end
+
       # Always unsubscribe our local SQL subscriber
       begin
         if sql_notification_subscription && defined?(ActiveSupport) && defined?(ActiveSupport::Notifications)
@@ -225,7 +240,7 @@ module DeadBro
       sql_time_ms = local_sql_queries.sum { |q| (q[:duration_ms] || 0.0).to_f }.round(2)
 
       # Group SQL queries by normalized pattern to show frequency and cost
-      query_signatures = Hash.new { |h, k| h[k] = { count: 0, total_time_ms: 0.0, type: nil } }
+      query_signatures = Hash.new { |h, k| h[k] = {count: 0, total_time_ms: 0.0, type: nil} }
       local_sql_queries.each do |q|
         sig = (q[:sql] || "UNKNOWN").to_s
         entry = query_signatures[sig]
@@ -236,55 +251,41 @@ module DeadBro
 
       top_query_signatures = query_signatures.sort_by { |_, data| -data[:count] }.first(3)
 
-      memory_after_mb = memory_before_mb
-      memory_delta_mb = 0.0
-      detailed_memory_summary = nil
+      # Capture post-block memory state — always, regardless of config.
+      gc_after = begin; GC.stat; rescue; {}; end
+      memory_after_mb = begin; DeadBro::MemoryHelpers.rss_mb; rescue; memory_before_mb; end
+      object_counts_after = begin
+        defined?(ObjectSpace) && ObjectSpace.respond_to?(:count_objects) ? ObjectSpace.count_objects.dup : {}
+      rescue; {}; end
 
-      raw_events = {}
-      if memory_tracking_started
-        begin
-          raw_events = DeadBro::MemoryTrackingSubscriber.stop_request_tracking || {}
-        rescue
-          raw_events = {}
-        end
-      end
-
-      begin
-        # Prefer values from detailed tracking when available
-        if raw_events[:memory_before]
-          memory_before_mb = raw_events[:memory_before]
-        end
+      memory_delta_mb = (memory_after_mb - memory_before_mb).round(2)
 
-        if raw_events[:memory_after]
-          memory_after_mb = raw_events[:memory_after]
-        else
-          if defined?(DeadBro::MemoryTrackingSubscriber)
-            memory_after_mb = DeadBro::MemoryTrackingSubscriber.memory_usage_mb
-          else
-            memory_after_mb = memory_before_mb
+      # Large object scan — full ObjectSpace walk. analyze is debug-only, not hot path.
+      large_objects = begin
+        if defined?(ObjectSpace) && ObjectSpace.respond_to?(:each_object) && ObjectSpace.respond_to?(:memsize_of)
+          found = []
+          ObjectSpace.each_object do |obj|
+            size = begin; ObjectSpace.memsize_of(obj); rescue; 0; end
+            next unless size > 1_000_000
+            klass = begin; obj.class.name || "Unknown"; rescue; "Unknown"; end
+            found << {class_name: klass, size_mb: (size / 1_000_000.0).round(2)}
+            break if found.length >= 50
           end
+          found.sort_by { |h| -h[:size_mb] }
+        else
+          []
         end
-      rescue
-        memory_after_mb = memory_before_mb
-      end
-
-      memory_delta_mb = (memory_after_mb - memory_before_mb).round(2)
+      rescue; []; end
 
-      if memory_tracking_started && !raw_events.empty?
-        begin
-          perf = DeadBro::MemoryTrackingSubscriber.analyze_memory_performance(raw_events) || {}
-
-          detailed_memory_summary = {
-            memory_growth_mb: (perf[:memory_growth_mb] || memory_delta_mb).to_f,
-            gc_count_increase: perf.dig(:gc_efficiency, :gc_count_increase) || 0,
-            heap_pages_increase: perf.dig(:gc_efficiency, :heap_pages_increase) || 0,
-            total_allocated_size_mb: (perf[:total_allocated_size_mb] || 0.0).to_f,
-            top_allocating_classes: (perf[:top_allocating_classes] || []).first(3)
-          }
-        rescue
-          detailed_memory_summary = nil
-        end
-      end
+      detailed_memory_summary = DeadBro::MemoryDetails.build(
+        gc_before: gc_before,
+        gc_after: gc_after,
+        memory_before_mb: memory_before_mb,
+        memory_after_mb: memory_after_mb,
+        object_counts_before: object_counts_before,
+        object_counts_after: object_counts_after,
+        large_objects: large_objects
+      )
 
       sql_queries_segment = ""
       unless top_query_signatures.empty?
@@ -297,28 +298,17 @@ module DeadBro
         sql_queries_segment = ", sql_top_queries=[#{formatted_queries.join(" | ")}]"
       end
 
-      base_summary = "Analysis for #{label} - total_time=#{total_time_ms}ms, " \
-                     "sql_queries=#{sql_count}, sql_time=#{sql_time_ms}ms, " \
-                     "memory_before=#{memory_before_mb.round(2)}MB, " \
-                     "memory_after=#{memory_after_mb.round(2)}MB, " \
-                     "memory_delta=#{memory_delta_mb}MB" \
-                     "#{sql_queries_segment}"
-
-      summary =
-        if detailed_memory_summary
-          top_classes = (detailed_memory_summary[:top_allocating_classes] || []).map { |c|
-            "#{c[:class_name]}:#{c[:size_mb]}MB"
-          }.join(", ")
-
-          "#{base_summary}, " \
-            "memory_growth=#{detailed_memory_summary[:memory_growth_mb].round(2)}MB, " \
-            "gc_runs=+#{detailed_memory_summary[:gc_count_increase]}, " \
-            "heap_pages=+#{detailed_memory_summary[:heap_pages_increase]}, " \
-            "allocated=#{detailed_memory_summary[:total_allocated_size_mb].round(2)}MB, " \
-            "top_allocators=[#{top_classes}]"
-        else
-          base_summary
-        end
+      warnings = detailed_memory_summary[:warnings]
+      warnings_segment = warnings.any? ? ", warnings=[#{warnings.join(", ")}]" : ""
+      summary = "Analysis for #{label} - total_time=#{total_time_ms}ms, " \
+                "sql_queries=#{sql_count}, sql_time=#{sql_time_ms}ms, " \
+                "memory_before=#{memory_before_mb.round(2)}MB, " \
+                "memory_after=#{memory_after_mb.round(2)}MB, " \
+                "memory_delta=#{memory_delta_mb}MB, " \
+                "gc_collections=+#{detailed_memory_summary[:gc_collections]}, " \
+                "heap_pages_added=+#{detailed_memory_summary[:heap_pages_added]}, " \
+                "new_objects=+#{detailed_memory_summary[:new_objects]}" \
+                "#{sql_queries_segment}#{warnings_segment}"
 
       begin
         DeadBro.logger.info(summary)
@@ -348,7 +338,8 @@ module DeadBro
         memory_before_mb: memory_before_mb,
         memory_after_mb: memory_after_mb,
         memory_delta_mb: memory_delta_mb,
-        memory_details: detailed_memory_summary
+        memory_details: detailed_memory_summary,
+        verbose: verbose
       }
     end