dead_bro 0.2.1 → 0.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fb42d69f24067aad16e5b9287d018590cd4876d5d37d40c4903d4216af721054
-  data.tar.gz: 27ce42b49dd15c548cebbbf8f95cb294c0479da8a3c41a1a8413e855fe929908
+  metadata.gz: 64333e774f85e0505014b6a0a6170e6721c0be30f1d3103b214fabdc7faacd8f
+  data.tar.gz: 82d6fc30651fcc2ee54904c6dff7b7cc36bd56c1a27a58ee726429c8b592b50a
 SHA512:
-  metadata.gz: daeeb6923d46b072535cff1e03d89b7f9cb7f5d3373bfdcb36c36f876c3460dbc612885c65940f2b65f99ce3929cefb41b9db1204ce22e8601eee9987b22a73c
-  data.tar.gz: 59335da8149d74c7e1e00be6ba7dc700a09eb261bb4e5322fd22914c57f57f468ee34733973ab08125c79072c9ff59bba42990bd9cc5721aff5484e38fea3243
+  metadata.gz: f7fc637b60a2990c3e3cfd6c39a5adbbebde198b11c1da5ff1127199ee05e900c6b971bccc740b1552f53156717511c2244dc7e70f736ac2b2110a2e0291d577
+  data.tar.gz: 1bed47b5f0d4dabc1e851631c00701802207769280b82d2809afd7cf75fa3e5be5dfaf5940ed853234dfdf659911512f56a383020b2bb027bce6eea8d1288637

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

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
@@ -63,8 +82,10 @@ module DeadBro
           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
 
@@ -354,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.1"
+  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.1
+  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: []