dead_bro 0.2.4 → 0.2.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c6e2fe55b896183a75b3590cb0939c3cc1326822eb6be81bbd147cebb9ebbee2
-  data.tar.gz: fed15de1f8aa27c1fb6df413dc3cf8b1d6de9f09ec983f28c52d00afbccacd41
+  metadata.gz: 7e977f41766dfbcf7ca52cf14aafb217595f35860746a553bd9386b1ddfe7797
+  data.tar.gz: 24858e179f45181d6d144352347ed3f760a19abe53cead83c80eb4644e281f39
 SHA512:
-  metadata.gz: 278bcd7b6da8de36b01a8c41c5325af407c150b3094aff5b358d6609ecea052970be33cfcba901378ddbdfe9fbfdeeb1a228571b5786e1538b6252c116595fc2
-  data.tar.gz: 27bc67cfa0f02510c4b52426a66151d4c1a828229dedc2468bfc899d589bed1d6e7e132c864f4e55c263162ead93be22ab91bf71e5ba3c95ed028fbf67c36cd6
+  metadata.gz: 7310571657927f6404088b2605d710cb9e107d5e63231cddcf785ffc9cc22a78ff634d5bc5969e34d08e634ed0cdc46f85f8f2d6937bc05ebe9af14b00c4968c
+  data.tar.gz: eaaec05db2cdf1d2da03cfa873c333286d891e33cb2e37d6b347b319a3ae8481f142182d87c3ce20bd2990829075aa236e52c9f52388d2799fc862b1511ceabd

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
@@ -44,9 +62,10 @@ module DeadBro
         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
       }
     end
@@ -58,7 +77,7 @@ module DeadBro
       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,6 +90,16 @@ module DeadBro
       events || {}
     end
 
+    # Record request-level allocation counters from Rails instrumentation.
+    def self.record_request_allocations(allocations:, allocated_bytes:)
+      return unless Thread.current[THREAD_LOCAL_KEY]
+
+      Thread.current[THREAD_LOCAL_KEY][:request_allocations] = {
+        allocations: allocations,
+        allocated_bytes: allocated_bytes
+      }
+    end
+
     def self.track_allocation(data, started, finished)
       return unless Thread.current[THREAD_LOCAL_KEY]
 
@@ -122,6 +151,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 +162,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 +217,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/version.rb

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

data/lib/dead_bro.rb

@@ -84,4 +84,275 @@ module DeadBro
   # Shared constant for tracking start time (used by all subscribers)
   TRACKING_START_TIME_KEY = :dead_bro_tracking_start_time
   MAX_TRACKING_DURATION_SECONDS = 3600 # 1 hour
+
+  # Analyze a block of code by tracking its runtime, SQL queries, and memory usage.
+  #
+  # Usage:
+  #   DeadBro.analyze("load users") do
+  #     User.where(active: true).to_a
+  #   end
+  #
+  # This will print a summary to the console (or Rails logger) including:
+  # - total time the block took
+  # - number of SQL queries executed
+  # - total SQL time
+  # - breakdown of distinct SQL query patterns (count and total time)
+  # - memory before/after and delta
+  # - when detailed memory tracking is enabled, GC and allocation stats
+  #
+  # The return value of this method is a hash with the following keys:
+  # - :label
+  # - :total_time_ms
+  # - :sql_count
+  # - :sql_time_ms
+  # - :sql_queries (array of distinct query patterns with counts and timings)
+  # - :memory_before_mb
+  # - :memory_after_mb
+  # - :memory_delta_mb
+  # - :memory_details (detailed GC/allocation stats when available)
+  def self.analyze(label = nil)
+    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
+      end
+    rescue
+    end
+
+    begin
+      if defined?(DeadBro::MemoryTrackingSubscriber)
+        memory_before_mb = DeadBro::MemoryTrackingSubscriber.memory_usage_mb
+      else
+        memory_before_mb = 0.0
+      end
+    rescue
+      memory_before_mb = 0.0
+    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
+    # depend on request/job instrumentation.
+    current_thread = Thread.current
+    local_sql_queries = []
+    sql_notification_subscription = nil
+
+    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 =
+          ActiveSupport::Notifications.subscribe(event_name) do |_name, started, finished, _id, data|
+            # Only count queries executed on this thread and skip schema queries
+            next unless Thread.current == current_thread
+            next if data[:name] == "SCHEMA"
+
+            duration_ms = begin
+              ((finished - started) * 1000.0).round(2)
+            rescue
+              0.0
+            end
+
+            raw_sql = data[:sql].to_s
+            # Normalize SQL so identical logical queries group together
+            normalized_sql = begin
+              sql = DeadBro::SqlSubscriber.sanitize_sql(raw_sql)
+              # Collapse whitespace
+              sql = sql.gsub(/\s+/, " ").strip
+              # Normalize numeric literals and quoted strings to '?'
+              sql = sql.gsub(/=\s*\d+(\.\d+)?/i, "= ?")
+              sql = sql.gsub(/=\s*'[^']*'/i, "= ?")
+              sql
+            rescue
+              raw_sql.to_s.strip
+            end
+
+            query_type = begin
+              raw_sql.strip.split.first.to_s.upcase
+            rescue
+              "SQL"
+            end
+
+            local_sql_queries << {
+              duration_ms: duration_ms,
+              sql: normalized_sql,
+              query_type: query_type
+            }
+          end
+      end
+    rescue
+      sql_notification_subscription = nil
+    end
+
+    block_start = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+
+    error = nil
+    result = nil
+    analysis_result = nil
+
+    begin
+      result = yield
+    rescue => e
+      error = e
+    ensure
+      # Always unsubscribe our local SQL subscriber
+      begin
+        if sql_notification_subscription && defined?(ActiveSupport) && defined?(ActiveSupport::Notifications)
+          ActiveSupport::Notifications.unsubscribe(sql_notification_subscription)
+        end
+      rescue
+      end
+
+      total_time_ms = begin
+        elapsed = Process.clock_gettime(Process::CLOCK_MONOTONIC) - block_start
+        (elapsed * 1000.0).round(2)
+      rescue
+        0.0
+      end
+
+      # Aggregate SQL metrics from our local subscription
+      sql_count = local_sql_queries.length
+      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 } }
+      local_sql_queries.each do |q|
+        sig = (q[:sql] || "UNKNOWN").to_s
+        entry = query_signatures[sig]
+        entry[:count] += 1
+        entry[:total_time_ms] += (q[:duration_ms] || 0.0).to_f
+        entry[:type] ||= q[:query_type]
+      end
+
+      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
+
+      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
+
+        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
+          end
+        end
+      rescue
+        memory_after_mb = memory_before_mb
+      end
+
+      memory_delta_mb = (memory_after_mb - memory_before_mb).round(2)
+
+      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
+
+      sql_queries_segment = ""
+      unless top_query_signatures.empty?
+        formatted_queries = top_query_signatures.map do |sig, data|
+          type = data[:type] || "SQL"
+          count = data[:count]
+          total_ms = data[:total_time_ms].round(2)
+          "#{type} #{sig} (#{count}x, #{total_ms}ms)"
+        end
+        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
+
+      begin
+        DeadBro.logger.info(summary)
+      rescue
+        begin
+          $stdout.puts("[DeadBro] #{summary}")
+        rescue
+        end
+      end
+
+      # Build structured result hash to return to the caller
+      sql_queries_detail = query_signatures.map do |sig, data|
+        {
+          sql: sig,
+          query_type: data[:type] || "SQL",
+          count: data[:count],
+          total_time_ms: data[:total_time_ms].round(2)
+        }
+      end
+
+      analysis_result = {
+        label: label,
+        total_time_ms: total_time_ms,
+        sql_count: sql_count,
+        sql_time_ms: sql_time_ms,
+        sql_queries: sql_queries_detail,
+        memory_before_mb: memory_before_mb,
+        memory_after_mb: memory_after_mb,
+        memory_delta_mb: memory_delta_mb,
+        memory_details: detailed_memory_summary
+      }
+    end
+
+    raise error if error
+    analysis_result
+  end
 end

metadata

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