dead_bro 0.2.0 → 0.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2d751a73992758c9392fbf0a89445536ce1a97cd2aea29470e54c4da62075e6b
-  data.tar.gz: e868200d7940c736922ea80e0a5d98fd665a86f1258725e9db33098ccbe75927
+  metadata.gz: 64333e774f85e0505014b6a0a6170e6721c0be30f1d3103b214fabdc7faacd8f
+  data.tar.gz: 82d6fc30651fcc2ee54904c6dff7b7cc36bd56c1a27a58ee726429c8b592b50a
 SHA512:
-  metadata.gz: 2ae9d9a17ca3975e68fdd762dd1f93eb173fca163ba01fdd6bea4813c0e7fca6566fee6943ee518b20f5f7b624cbc96b17dc0afcb45837cca703a94cfdde5e4b
-  data.tar.gz: 631e395e237463d6d76b0bc08868ee28712f90450a1c22935f21c05e1ff766c3b2b6f906249cbe6f29e8217c73a5bd196e746c6fab614e9f722f199f64e60eaa
+  metadata.gz: f7fc637b60a2990c3e3cfd6c39a5adbbebde198b11c1da5ff1127199ee05e900c6b971bccc740b1552f53156717511c2244dc7e70f736ac2b2110a2e0291d577
+  data.tar.gz: 1bed47b5f0d4dabc1e851631c00701802207769280b82d2809afd7cf75fa3e5be5dfaf5940ed853234dfdf659911512f56a383020b2bb027bce6eea8d1288637

data/README.md

@@ -22,9 +22,9 @@ You can set via an initializer:
 
 
 ```ruby
-DeadBro.configure do |cfg|
-  cfg.api_key = ENV["dead_bro_API_KEY"]
-  cfg.enabled = true
+DeadBro.configure do |config|
+  config.api_key = ENV["DEAD_BRO_API_KEY"]
+  config.enabled = true
 end
 ```
 
@@ -180,7 +180,7 @@ DeadBro can automatically run `EXPLAIN ANALYZE` on slow SQL queries to help you
 
 ```ruby
 DeadBro.configure do |config|
-  config.api_key = ENV['dead_bro_API_KEY']
+  config.api_key = ENV['DEAD_BRO_API_KEY']
   config.enabled = true
   
   # Enable EXPLAIN ANALYZE for queries slower than 500ms

data/lib/dead_bro/cache_subscriber.rb

@@ -5,6 +5,7 @@ require "active_support/notifications"
 module DeadBro
   class CacheSubscriber
     THREAD_LOCAL_KEY = :dead_bro_cache_events
+    MAX_TRACKED_EVENTS = 1000
 
     EVENTS = [
       "cache_read.active_support",
@@ -24,7 +25,9 @@ module DeadBro
 
           duration_ms = ((finished - started) * 1000.0).round(2)
           event = build_event(name, data, duration_ms)
-          Thread.current[THREAD_LOCAL_KEY] << event if event
+          if event && should_continue_tracking?
+            Thread.current[THREAD_LOCAL_KEY] << event
+          end
         end
       rescue
       end
@@ -42,6 +45,24 @@ module DeadBro
       events || []
     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.build_event(name, data, duration_ms)
       return nil unless data.is_a?(Hash)
 

data/lib/dead_bro/client.rb

@@ -37,6 +37,29 @@ module DeadBro
       nil
     end
 
+    def post_job_stats(payload)
+      return if @configuration.api_key.nil?
+      return unless @configuration.enabled
+      return unless @configuration.job_queue_monitoring_enabled
+
+      # Check circuit breaker before making request
+      if @circuit_breaker && @configuration.circuit_breaker_enabled
+        if @circuit_breaker.state == :open
+          # Check if we should attempt a reset to half-open state
+          if @circuit_breaker.should_attempt_reset?
+            @circuit_breaker.transition_to_half_open!
+          else
+            return
+          end
+        end
+      end
+
+      # Make the HTTP request (async) to jobs endpoint
+      make_job_stats_request(payload, @configuration.api_key)
+
+      nil
+    end
+
     private
 
     def create_circuit_breaker
@@ -99,6 +122,56 @@ module DeadBro
       nil
     end
 
+    def make_job_stats_request(payload, api_key)
+      use_staging = ENV["USE_STAGING_ENDPOINT"] && !ENV["USE_STAGING_ENDPOINT"].empty?
+      production_url = use_staging ? "https://deadbro.aberatii.com/apm/v1/jobs" : "https://www.deadbro.com/apm/v1/jobs"
+      endpoint_url = @configuration.ruby_dev ? "http://localhost:3100/apm/v1/jobs" : production_url
+      uri = URI.parse(endpoint_url)
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.use_ssl = (uri.scheme == "https")
+      http.open_timeout = @configuration.open_timeout
+      http.read_timeout = @configuration.read_timeout
+
+      request = Net::HTTP::Post.new(uri.request_uri)
+      request["Content-Type"] = "application/json"
+      request["Authorization"] = "Bearer #{api_key}"
+      body = {payload: payload, sent_at: Time.now.utc.iso8601, revision: @configuration.resolve_deploy_id}
+      request.body = JSON.dump(body)
+
+      # Fire-and-forget using a short-lived thread to avoid blocking
+      Thread.new do
+        response = http.request(request)
+
+        if response
+          # Update circuit breaker based on response
+          if @circuit_breaker && @configuration.circuit_breaker_enabled
+            if response.is_a?(Net::HTTPSuccess)
+              @circuit_breaker.send(:on_success)
+            else
+              @circuit_breaker.send(:on_failure)
+            end
+          end
+        elsif @circuit_breaker && @configuration.circuit_breaker_enabled
+          # Treat nil response as failure for circuit breaker
+          @circuit_breaker.send(:on_failure)
+        end
+
+        response
+      rescue Timeout::Error
+        # Update circuit breaker on timeout
+        if @circuit_breaker && @configuration.circuit_breaker_enabled
+          @circuit_breaker.send(:on_failure)
+        end
+      rescue
+        # Update circuit breaker on exception
+        if @circuit_breaker && @configuration.circuit_breaker_enabled
+          @circuit_breaker.send(:on_failure)
+        end
+      end
+
+      nil
+    end
+
     def log_debug(message)
       if defined?(Rails) && Rails.respond_to?(:logger) && Rails.logger
         Rails.logger.debug(message)

data/lib/dead_bro/configuration.rb

@@ -5,7 +5,8 @@ module DeadBro
     attr_accessor :api_key, :open_timeout, :read_timeout, :enabled, :ruby_dev, :memory_tracking_enabled, 
     :allocation_tracking_enabled, :circuit_breaker_enabled, :circuit_breaker_failure_threshold, :circuit_breaker_recovery_timeout, 
     :circuit_breaker_retry_timeout, :sample_rate, :excluded_controllers, :excluded_jobs,
-    :exclusive_controllers, :exclusive_jobs, :deploy_id, :slow_query_threshold_ms, :explain_analyze_enabled
+    :exclusive_controllers, :exclusive_jobs, :deploy_id, :slow_query_threshold_ms, :explain_analyze_enabled,
+    :job_queue_monitoring_enabled
 
     def initialize
       @api_key = nil
@@ -28,6 +29,7 @@ module DeadBro
       @deploy_id = resolve_deploy_id
       @slow_query_threshold_ms = 500 # Default: 500ms
       @explain_analyze_enabled = false # Enable EXPLAIN ANALYZE for slow queries by default
+      @job_queue_monitoring_enabled = false # Disabled by default
     end
 
     def resolve_deploy_id
@@ -107,7 +109,7 @@ module DeadBro
     def resolve_api_key
       return @api_key unless @api_key.nil?
       
-      ENV["dead_bro_API_KEY"]
+      ENV["DEAD_BRO_API_KEY"]
     end
 
     def sample_rate=(value)

data/lib/dead_bro/http_instrumentation.rb

@@ -6,6 +6,8 @@ require "net/http"
 module DeadBro
   module HttpInstrumentation
     EVENT_NAME = "outgoing.http"
+    THREAD_LOCAL_KEY = :dead_bro_http_events
+    MAX_TRACKED_EVENTS = 1000
 
     def self.install!(client: Client.new)
       install_net_http!(client)
@@ -52,8 +54,8 @@ module DeadBro
                   exception: error && error.class.name
                 }
                 # Accumulate per-request; only send with controller metric
-                if Thread.current[:dead_bro_http_events]
-                  Thread.current[:dead_bro_http_events] << payload
+                if Thread.current[THREAD_LOCAL_KEY] && should_continue_tracking?
+                  Thread.current[THREAD_LOCAL_KEY] << payload
                 end
               end
             rescue
@@ -96,8 +98,8 @@ module DeadBro
                   duration_ms: duration_ms
                 }
                 # Accumulate per-request; only send with controller metric
-                if Thread.current[:dead_bro_http_events]
-                  Thread.current[:dead_bro_http_events] << payload
+                if Thread.current[THREAD_LOCAL_KEY] && should_continue_tracking?
+                  Thread.current[THREAD_LOCAL_KEY] << payload
                 end
               end
             rescue
@@ -109,5 +111,23 @@ module DeadBro
       ::Typhoeus::Request.prepend(mod) unless ::Typhoeus::Request.ancestors.include?(mod)
     rescue
     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
   end
 end

data/lib/dead_bro/job_queue_monitor.rb

@@ -0,0 +1,395 @@
+# frozen_string_literal: true
+
+module DeadBro
+  class JobQueueMonitor
+    def initialize(client: DeadBro.client)
+      @client = client
+      @thread = nil
+      @running = false
+    end
+
+    def start
+      return if @running
+      return unless DeadBro.configuration.job_queue_monitoring_enabled
+      return unless DeadBro.configuration.enabled
+
+      @running = true
+      @thread = Thread.new do
+        Thread.current.abort_on_exception = false
+        loop do
+          break unless @running
+
+          begin
+            stats = collect_queue_stats
+            @client.post_job_stats(stats) if stats
+          rescue => e
+            log_error("Error collecting job queue stats: #{e.message}")
+          end
+
+          # Sleep for 60 seconds (1 minute)
+          sleep(120)
+        end
+      end
+
+      @thread
+    end
+
+    def stop
+      @running = false
+      @thread&.join(5) # Wait up to 5 seconds for thread to finish
+      @thread = nil
+    end
+
+    private
+
+    def collect_queue_stats
+      stats = {
+        timestamp: Time.now.utc.iso8601,
+        queue_system: detect_queue_system,
+        environment: Rails.env,
+        queues: {}
+      }
+
+      case stats[:queue_system]
+      when :sidekiq
+        stats[:queues] = collect_sidekiq_stats
+      when :solid_queue
+        stats[:queues] = collect_solid_queue_stats
+      when :delayed_job
+        stats[:queues] = collect_delayed_job_stats
+      when :good_job
+        stats[:queues] = collect_good_job_stats
+      else
+        return nil # Unknown queue system, don't send stats
+      end
+
+      stats
+    end
+
+    def detect_queue_system
+      return :sidekiq if defined?(Sidekiq)
+      return :solid_queue if defined?(SolidQueue)
+      return :delayed_job if defined?(Delayed::Job)
+      return :good_job if defined?(GoodJob)
+      :unknown
+    end
+
+    def collect_sidekiq_stats
+      return {} unless defined?(Sidekiq)
+
+      stats = {
+        total_queued: 0,
+        total_busy: 0,
+        queues: {}
+      }
+
+      begin
+        # Get queue sizes - try to access Queue class (will trigger autoload if needed)
+        begin
+          queue_class = Sidekiq.const_get(:Queue)
+          if queue_class.respond_to?(:all)
+            queue_class.all.each do |queue|
+              queue_name = queue.name
+              size = queue.size
+              stats[:queues][queue_name] = {
+                queued: size,
+                busy: 0,
+                scheduled: 0,
+                retries: 0
+              }
+              stats[:total_queued] += size
+            end
+          end
+        rescue NameError => e
+          log_error("Sidekiq::Queue not available: #{e.message}")
+        rescue => e
+          log_error("Error accessing Sidekiq::Queue: #{e.message}")
+        end
+
+        # Get busy workers
+        begin
+          workers_class = Sidekiq.const_get(:Workers)
+          workers = workers_class.new
+          workers.each do |process_id, thread_id, work|
+            next unless work
+            queue_name = work["queue"] || "default"
+            stats[:queues][queue_name] ||= { queued: 0, busy: 0, scheduled: 0, retries: 0 }
+            stats[:queues][queue_name][:busy] += 1
+            stats[:total_busy] += 1
+          end
+        rescue NameError
+          # Workers class not available, try fallback
+          if Sidekiq.respond_to?(:workers)
+            # Fallback for older Sidekiq versions
+            begin
+              workers = Sidekiq.workers
+              if workers.respond_to?(:each)
+                workers.each do |worker|
+                  queue_name = worker.respond_to?(:queue) ? worker.queue : "default"
+                  stats[:queues][queue_name] ||= { queued: 0, busy: 0, scheduled: 0, retries: 0 }
+                  stats[:queues][queue_name][:busy] += 1
+                  stats[:total_busy] += 1
+                end
+              end
+            rescue => e
+              log_error("Error getting Sidekiq workers (fallback): #{e.message}")
+            end
+          end
+        rescue => e
+          log_error("Error getting Sidekiq workers: #{e.message}")
+        end
+
+        # Get scheduled jobs
+        begin
+          scheduled_set_class = Sidekiq.const_get(:ScheduledSet)
+          scheduled_set = scheduled_set_class.new
+          stats[:total_scheduled] = scheduled_set.size
+        rescue NameError
+          # ScheduledSet not available, skip
+        rescue => e
+          log_error("Error getting Sidekiq scheduled jobs: #{e.message}")
+        end
+
+        # Get retries
+        begin
+          retry_set_class = Sidekiq.const_get(:RetrySet)
+          retry_set = retry_set_class.new
+          stats[:total_retries] = retry_set.size
+        rescue NameError
+          # RetrySet not available, skip
+        rescue => e
+          log_error("Error getting Sidekiq retries: #{e.message}")
+        end
+
+        # Get dead jobs
+        begin
+          dead_set_class = Sidekiq.const_get(:DeadSet)
+          dead_set = dead_set_class.new
+          stats[:total_dead] = dead_set.size
+        rescue NameError
+          # DeadSet not available, skip
+        rescue => e
+          log_error("Error getting Sidekiq dead jobs: #{e.message}")
+        end
+
+        # Get process info
+        begin
+          process_set_class = Sidekiq.const_get(:ProcessSet)
+          process_set = process_set_class.new
+          stats[:processes] = process_set.size
+        rescue NameError
+          # ProcessSet not available, skip
+        rescue => e
+          log_error("Error getting Sidekiq processes: #{e.message}")
+        end
+      rescue => e
+        log_error("Error collecting Sidekiq stats: #{e.message}")
+        log_error("Backtrace: #{e.backtrace.first(5).join("\n")}")
+      end
+
+      stats
+    end
+
+    def collect_solid_queue_stats
+      return {} unless defined?(SolidQueue)
+
+      stats = {
+        total_queued: 0,
+        total_busy: 0,
+        queues: {}
+      }
+
+      begin
+        # Solid Queue uses ActiveJob and stores jobs in a database table
+        if defined?(ActiveRecord) && ActiveRecord::Base.connected? && ActiveRecord::Base.connection.table_exists?("solid_queue_jobs")
+          # Get queued jobs grouped by queue
+          result = ActiveRecord::Base.connection.execute(
+            "SELECT queue_name, COUNT(*) as count FROM solid_queue_jobs WHERE finished_at IS NULL GROUP BY queue_name"
+          )
+
+          parse_query_result(result).each do |row|
+            queue_name = (row["queue_name"] || row[:queue_name] || "default").to_s
+            count = (row["count"] || row[:count] || 0).to_i
+            stats[:queues][queue_name] = {
+              queued: count,
+              busy: 0,
+              scheduled: 0,
+              retries: 0
+            }
+            stats[:total_queued] += count
+          end
+
+          # Get busy jobs (claimed but not finished)
+          result = ActiveRecord::Base.connection.execute(
+            "SELECT queue_name, COUNT(*) as count FROM solid_queue_jobs WHERE finished_at IS NULL AND claimed_at IS NOT NULL GROUP BY queue_name"
+          )
+
+          parse_query_result(result).each do |row|
+            queue_name = (row["queue_name"] || row[:queue_name] || "default").to_s
+            count = (row["count"] || row[:count] || 0).to_i
+            stats[:queues][queue_name] ||= { queued: 0, busy: 0, scheduled: 0, retries: 0 }
+            stats[:queues][queue_name][:busy] = count
+            stats[:total_busy] += count
+          end
+
+          # Get scheduled jobs
+          result = ActiveRecord::Base.connection.execute(
+            "SELECT COUNT(*) as count FROM solid_queue_jobs WHERE scheduled_at > NOW()"
+          )
+          scheduled_count = parse_query_result(result).first
+          stats[:total_scheduled] = (scheduled_count&.dig("count") || scheduled_count&.dig(:count) || 0).to_i
+
+          # Get failed jobs
+          if ActiveRecord::Base.connection.table_exists?("solid_queue_failed_jobs")
+            result = ActiveRecord::Base.connection.execute(
+              "SELECT COUNT(*) as count FROM solid_queue_failed_jobs"
+            )
+            failed_count = parse_query_result(result).first
+            stats[:total_failed] = (failed_count&.dig("count") || failed_count&.dig(:count) || 0).to_i
+          end
+        end
+      rescue => e
+        log_error("Error collecting Solid Queue stats: #{e.message}")
+      end
+
+      stats
+    end
+
+    def collect_delayed_job_stats
+      return {} unless defined?(Delayed::Job)
+
+      stats = {
+        total_queued: 0,
+        total_busy: 0,
+        queues: {}
+      }
+
+      begin
+        # Delayed Job uses a single table
+        if defined?(ActiveRecord) && ActiveRecord::Base.connected? && ActiveRecord::Base.connection.table_exists?("delayed_jobs")
+          # Get queued jobs
+          queued = Delayed::Job.where("locked_at IS NULL AND attempts < max_attempts").count
+          stats[:total_queued] = queued
+          stats[:queues]["default"] = {
+            queued: queued,
+            busy: 0,
+            scheduled: 0,
+            retries: 0
+          }
+
+          # Get busy jobs (locked)
+          busy = Delayed::Job.where("locked_at IS NOT NULL AND locked_by IS NOT NULL").count
+          stats[:total_busy] = busy
+          stats[:queues]["default"][:busy] = busy
+
+          # Get failed jobs
+          failed = Delayed::Job.where("attempts >= max_attempts").count
+          stats[:total_failed] = failed
+        end
+      rescue => e
+        log_error("Error collecting Delayed Job stats: #{e.message}")
+      end
+
+      stats
+    end
+
+    def collect_good_job_stats
+      return {} unless defined?(GoodJob)
+
+      stats = {
+        total_queued: 0,
+        total_busy: 0,
+        queues: {}
+      }
+
+      begin
+        # Good Job uses ActiveJob and stores jobs in a database table
+        if defined?(ActiveRecord) && ActiveRecord::Base.connected? && ActiveRecord::Base.connection.table_exists?("good_jobs")
+          # Get queued jobs grouped by queue
+          result = ActiveRecord::Base.connection.execute(
+            "SELECT queue_name, COUNT(*) as count FROM good_jobs WHERE finished_at IS NULL GROUP BY queue_name"
+          )
+
+          parse_query_result(result).each do |row|
+            queue_name = (row["queue_name"] || row[:queue_name] || "default").to_s
+            count = (row["count"] || row[:count] || 0).to_i
+            stats[:queues][queue_name] = {
+              queued: count,
+              busy: 0,
+              scheduled: 0,
+              retries: 0
+            }
+            stats[:total_queued] += count
+          end
+
+          # Get busy jobs (running)
+          result = ActiveRecord::Base.connection.execute(
+            "SELECT queue_name, COUNT(*) as count FROM good_jobs WHERE finished_at IS NULL AND performed_at IS NOT NULL GROUP BY queue_name"
+          )
+
+          parse_query_result(result).each do |row|
+            queue_name = (row["queue_name"] || row[:queue_name] || "default").to_s
+            count = (row["count"] || row[:count] || 0).to_i
+            stats[:queues][queue_name] ||= { queued: 0, busy: 0, scheduled: 0, retries: 0 }
+            stats[:queues][queue_name][:busy] = count
+            stats[:total_busy] += count
+          end
+
+          # Get scheduled jobs
+          result = ActiveRecord::Base.connection.execute(
+            "SELECT COUNT(*) as count FROM good_jobs WHERE scheduled_at > NOW()"
+          )
+          scheduled_count = parse_query_result(result).first
+          stats[:total_scheduled] = (scheduled_count&.dig("count") || scheduled_count&.dig(:count) || 0).to_i
+
+          # Get failed jobs
+          result = ActiveRecord::Base.connection.execute(
+            "SELECT COUNT(*) as count FROM good_jobs WHERE finished_at IS NOT NULL AND error IS NOT NULL"
+          )
+          failed_count = parse_query_result(result).first
+          stats[:total_failed] = (failed_count&.dig("count") || failed_count&.dig(:count) || 0).to_i
+        end
+      rescue => e
+        log_error("Error collecting Good Job stats: #{e.message}")
+      end
+
+      stats
+    end
+
+    def parse_query_result(result)
+      # Handle different database adapter result formats
+      if result.respond_to?(:each)
+        # PostgreSQL PG::Result or similar
+        if result.respond_to?(:values)
+          # Convert to array of hashes
+          columns = result.fields rescue result.column_names rescue []
+          result.values.map do |row|
+            columns.each_with_index.each_with_object({}) do |(col, idx), hash|
+              hash[col.to_s] = row[idx]
+              hash[col.to_sym] = row[idx]
+            end
+          end
+        elsif result.is_a?(Array)
+          # Already an array
+          result
+        else
+          # Try to convert to array
+          result.to_a
+        end
+      else
+        []
+      end
+    rescue => e
+      log_error("Error parsing query result: #{e.message}")
+      []
+    end
+
+    def log_error(message)
+      if defined?(Rails) && Rails.respond_to?(:logger) && Rails.logger
+        Rails.logger.error("[DeadBro::JobQueueMonitor] #{message}")
+      else
+        $stderr.puts("[DeadBro::JobQueueMonitor] #{message}")
+      end
+    end
+  end
+end

data/lib/dead_bro/job_sql_tracking_middleware.rb

@@ -7,6 +7,10 @@ module DeadBro
       ActiveSupport::Notifications.subscribe("perform_start.active_job") do |name, started, finished, _unique_id, data|
         # Clear logs for this job
         DeadBro.logger.clear
+        
+        # Set tracking start time once for all subscribers (before starting any tracking)
+        Thread.current[DeadBro::TRACKING_START_TIME_KEY] = Time.now
+        
         DeadBro::SqlSubscriber.start_request_tracking
 
         # Start lightweight memory tracking for this job

data/lib/dead_bro/job_subscriber.rb

@@ -28,6 +28,14 @@ module DeadBro
 
         duration_ms = ((finished - started) * 1000.0).round(2)
 
+        # 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]
+          DeadBro.logger.clear
+          Thread.current[DeadBro::TRACKING_START_TIME_KEY] = Time.now
+          DeadBro::SqlSubscriber.start_request_tracking
+        end
+
         # Get SQL queries executed during this job
         sql_queries = DeadBro::SqlSubscriber.stop_request_tracking
 
@@ -96,6 +104,14 @@ module DeadBro
         duration_ms = ((finished - started) * 1000.0).round(2)
         exception = data[:exception_object]
 
+        # 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]
+          DeadBro.logger.clear
+          Thread.current[DeadBro::TRACKING_START_TIME_KEY] = Time.now
+          DeadBro::SqlSubscriber.start_request_tracking
+        end
+
         # Get SQL queries executed during this job
         sql_queries = DeadBro::SqlSubscriber.stop_request_tracking
 

data/lib/dead_bro/railtie.rb

@@ -55,6 +55,13 @@ if defined?(Rails) && defined?(Rails::Railtie)
             DeadBro::JobSqlTrackingMiddleware.subscribe!
             DeadBro::JobSubscriber.subscribe!(client: shared_client)
           end
+
+          # Start job queue monitoring if enabled
+          if DeadBro.configuration.job_queue_monitoring_enabled
+            require "dead_bro/job_queue_monitor"
+            DeadBro.job_queue_monitor = DeadBro::JobQueueMonitor.new(client: shared_client)
+            DeadBro.job_queue_monitor.start
+          end
         rescue
           # Never raise in Railtie init
         end

data/lib/dead_bro/redis_subscriber.rb

@@ -3,6 +3,7 @@
 module DeadBro
   class RedisSubscriber
     THREAD_LOCAL_KEY = :dead_bro_redis_events
+    MAX_TRACKED_EVENTS = 1000
 
     def self.subscribe!
       install_redis_instrumentation!
@@ -86,7 +87,7 @@ module DeadBro
                 error: error ? error.class.name : nil
               }
 
-              if Thread.current[RedisSubscriber::THREAD_LOCAL_KEY]
+              if Thread.current[RedisSubscriber::THREAD_LOCAL_KEY] && RedisSubscriber.should_continue_tracking?
                 Thread.current[RedisSubscriber::THREAD_LOCAL_KEY] << event
               end
             rescue
@@ -114,7 +115,7 @@ module DeadBro
                 db: safe_db(@db)
               }
 
-              if Thread.current[RedisSubscriber::THREAD_LOCAL_KEY]
+              if Thread.current[RedisSubscriber::THREAD_LOCAL_KEY] && RedisSubscriber.should_continue_tracking?
                 Thread.current[RedisSubscriber::THREAD_LOCAL_KEY] << event
               end
             rescue
@@ -142,7 +143,7 @@ module DeadBro
                 db: safe_db(@db)
               }
 
-              if Thread.current[RedisSubscriber::THREAD_LOCAL_KEY]
+              if Thread.current[RedisSubscriber::THREAD_LOCAL_KEY] && RedisSubscriber.should_continue_tracking?
                 Thread.current[RedisSubscriber::THREAD_LOCAL_KEY] << event
               end
             rescue
@@ -201,7 +202,9 @@ module DeadBro
             next unless Thread.current[THREAD_LOCAL_KEY]
             duration_ms = ((finished - started) * 1000.0).round(2)
             event = build_event(name, data, duration_ms)
-            Thread.current[THREAD_LOCAL_KEY] << event if event
+            if event && should_continue_tracking?
+              Thread.current[THREAD_LOCAL_KEY] << event
+            end
           end
         rescue
         end
@@ -218,6 +221,24 @@ module DeadBro
       events || []
     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.build_event(name, data, duration_ms)
       cmd = extract_command(data)
       {

data/lib/dead_bro/sql_subscriber.rb

@@ -14,6 +14,25 @@ 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
+    MAX_TRACKED_QUERIES = 1000
+
+    # 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
+      
+      # Check count limit
+      return false if events.length >= max_count
+      
+      # 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.subscribe!
       # Subscribe with a start/finish listener to measure allocations per query
@@ -58,11 +77,15 @@ module DeadBro
         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
-          start_explain_analyze_background(original_sql, data[:connection_id], query_info)
+          # Capture binds if available (type_casted_binds is preferred as they are ready for quoting)
+          binds = data[:type_casted_binds] || data[:binds]
+          start_explain_analyze_background(original_sql, data[:connection_id], query_info, binds)
         end
 
-        # Add to thread-local storage
-        Thread.current[THREAD_LOCAL_KEY] << query_info
+        # 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
+        end
       end
     end
 
@@ -142,7 +165,7 @@ module DeadBro
       true
     end
 
-    def self.start_explain_analyze_background(sql, connection_id, query_info)
+    def self.start_explain_analyze_background(sql, connection_id, query_info, binds = nil)
       return unless defined?(ActiveRecord)
       return unless ActiveRecord::Base.respond_to?(:connection)
       
@@ -160,8 +183,11 @@ module DeadBro
             connection = 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(sql, connection)
+          explain_sql = build_explain_query(final_sql, connection)
           
           # Execute the EXPLAIN query
           # For PostgreSQL, use select_all which returns ActiveRecord::Result
@@ -182,10 +208,8 @@ module DeadBro
           # This updates the hash that's already in the queries array
           if explain_plan && !explain_plan.to_s.strip.empty?
             query_info[:explain_plan] = explain_plan
-            append_log_to_thread(main_thread, :debug, "Captured EXPLAIN ANALYZE for slow query (#{query_info[:duration_ms]}ms): #{explain_plan[0..1000]}...")
           else
             query_info[:explain_plan] = nil
-            append_log_to_thread(main_thread, :debug, "EXPLAIN ANALYZE returned empty result. Result type: #{result.class}, Result: #{result.inspect[0..200]}")
           end
         rescue => e
           # Silently fail - don't let EXPLAIN break the application
@@ -267,6 +291,46 @@ module DeadBro
       end
     end
 
+    def self.interpolate_sql_with_binds(sql, binds, connection)
+      return sql if binds.nil? || binds.empty?
+      return sql unless connection
+
+      interpolated_sql = sql.dup
+      
+      # Handle $1, $2 style placeholders (PostgreSQL)
+      if interpolated_sql.include?("$1")
+        binds.each_with_index do |val, index|
+          # Get value from bind param (handle both raw values and ActiveRecord::Relation::QueryAttribute)
+          value = val
+          if val.respond_to?(:value_for_database)
+            value = val.value_for_database
+          elsif val.respond_to?(:value)
+            value = val.value
+          end
+          
+          quoted_value = connection.quote(value)
+          interpolated_sql = interpolated_sql.gsub("$#{index + 1}", quoted_value)
+        end
+      elsif interpolated_sql.include?("?")
+        # Handle ? style placeholders (MySQL, SQLite)
+        # We need to replace ? one by one in order
+        binds.each do |val|
+          # Get value from bind param
+          value = val
+          if val.respond_to?(:value_for_database)
+            value = val.value_for_database
+          elsif val.respond_to?(:value)
+            value = val.value
+          end
+          
+          quoted_value = connection.quote(value)
+          interpolated_sql = interpolated_sql.sub("?", quoted_value)
+        end
+      end
+      
+      interpolated_sql
+    end
+
     def self.format_explain_result(result, connection)
       adapter_name = connection.adapter_name.downcase
       
@@ -311,8 +375,12 @@ module DeadBro
         # Fallback to string representation
         result.to_s
       when "mysql", "mysql2", "trilogy"
-        # MySQL returns rows
-        if result.is_a?(Array)
+        # MySQL returns Mysql2::Result object which needs to be converted to array
+        if result.respond_to?(:to_a)
+          # Convert Mysql2::Result to array of hashes
+          rows = result.to_a
+          rows.map { |row| row.is_a?(Hash) ? row.values.join(" | ") : row.to_s }.join("\n")
+        elsif result.is_a?(Array)
           result.map { |row| row.is_a?(Hash) ? row.values.join(" | ") : row.to_s }.join("\n")
         else
           result.to_s

data/lib/dead_bro/sql_tracking_middleware.rb

@@ -42,6 +42,9 @@ module DeadBro
 
       # Start outgoing HTTP accumulation for this request
       Thread.current[:dead_bro_http_events] = []
+      
+      # Set tracking start time once for all subscribers (before starting any tracking)
+      Thread.current[DeadBro::TRACKING_START_TIME_KEY] = Time.now
 
       @app.call(env)
     ensure
@@ -71,8 +74,9 @@ module DeadBro
         Thread.current[:dead_bro_lightweight_memory] = nil
       end
 
-      # Clean up HTTP events
+      # Clean up HTTP events and tracking start time
       Thread.current[:dead_bro_http_events] = nil
+      Thread.current[DeadBro::TRACKING_START_TIME_KEY] = nil
     end
   end
 end

data/lib/dead_bro/version.rb

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

data/lib/dead_bro/view_rendering_subscriber.rb

@@ -10,6 +10,7 @@ module DeadBro
     RENDER_COLLECTION_EVENT = "render_collection.action_view"
 
     THREAD_LOCAL_KEY = :dead_bro_view_events
+    MAX_TRACKED_EVENTS = 1000
 
     def self.subscribe!(client: Client.new)
       # Track template rendering
@@ -78,11 +79,29 @@ module DeadBro
     end
 
     def self.add_view_event(view_info)
-      if Thread.current[THREAD_LOCAL_KEY]
+      if Thread.current[THREAD_LOCAL_KEY] && should_continue_tracking?
         Thread.current[THREAD_LOCAL_KEY] << view_info
       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)
 

data/lib/dead_bro.rb

@@ -18,6 +18,7 @@ module DeadBro
   autoload :MemoryHelpers, "dead_bro/memory_helpers"
   autoload :JobSubscriber, "dead_bro/job_subscriber"
   autoload :JobSqlTrackingMiddleware, "dead_bro/job_sql_tracking_middleware"
+  autoload :JobQueueMonitor, "dead_bro/job_queue_monitor"
   autoload :Logger, "dead_bro/logger"
   begin
     require "dead_bro/railtie"
@@ -66,4 +67,18 @@ module DeadBro
       ENV["RACK_ENV"] || ENV["RAILS_ENV"] || "development"
     end
   end
+
+  # Returns the job queue monitor instance
+  def self.job_queue_monitor
+    @job_queue_monitor
+  end
+
+  # Sets the job queue monitor instance
+  def self.job_queue_monitor=(monitor)
+    @job_queue_monitor = monitor
+  end
+
+  # 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
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: dead_bro
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.2.2
 platform: ruby
 authors:
 - Emanuel Comsa
@@ -27,6 +27,7 @@ files:
 - lib/dead_bro/configuration.rb
 - lib/dead_bro/error_middleware.rb
 - lib/dead_bro/http_instrumentation.rb
+- lib/dead_bro/job_queue_monitor.rb
 - lib/dead_bro/job_sql_tracking_middleware.rb
 - lib/dead_bro/job_subscriber.rb
 - lib/dead_bro/lightweight_memory_tracker.rb
@@ -60,7 +61,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.7
+rubygems_version: 4.0.3
 specification_version: 4
 summary: Minimal APM for Rails apps.
 test_files: []