dead_bro 0.2.8 → 0.2.9

data/lib/dead_bro/configuration.rb

@@ -11,11 +11,14 @@ module DeadBro
 
     # Remote-managed settings (overwritten by backend JSON `settings` on successful API responses)
     attr_accessor :memory_tracking_enabled, :allocation_tracking_enabled,
-      :sample_rate, :excluded_controllers, :excluded_jobs,
-      :exclusive_controllers, :exclusive_jobs, :slow_query_threshold_ms, :explain_analyze_enabled,
+      :sample_rate, :slow_query_threshold_ms, :explain_analyze_enabled,
       :job_queue_monitoring_enabled, :enable_db_stats, :enable_process_stats, :enable_system_stats,
       :max_sql_queries_to_send, :max_logs_to_send
 
+    # Readers for exclusion lists. Writers are defined below so we can compile
+    # and cache the regex form once, instead of rebuilding it per request.
+    attr_reader :excluded_controllers, :excluded_jobs, :exclusive_controllers, :exclusive_jobs
+
     # Tracks when we last received settings from the backend (in-memory only)
     attr_accessor :settings_received_at
 
@@ -56,10 +59,10 @@ module DeadBro
       @slow_query_threshold_ms = 500
       @max_sql_queries_to_send = 500
       @max_logs_to_send = 100
-      @excluded_controllers = []
-      @excluded_jobs = []
-      @exclusive_controllers = []
-      @exclusive_jobs = []
+      self.excluded_controllers = []
+      self.excluded_jobs = []
+      self.exclusive_controllers = []
+      self.exclusive_jobs = []
       @job_queue_monitoring_enabled = false
       @enable_db_stats = false
       @enable_process_stats = false
@@ -71,6 +74,26 @@ module DeadBro
       @settings_mutex = Mutex.new
     end
 
+    def excluded_controllers=(value)
+      @excluded_controllers = Array(value).map(&:to_s)
+      @compiled_excluded_controllers = compile_patterns(@excluded_controllers)
+    end
+
+    def excluded_jobs=(value)
+      @excluded_jobs = Array(value).map(&:to_s)
+      @compiled_excluded_jobs = compile_patterns(@excluded_jobs)
+    end
+
+    def exclusive_controllers=(value)
+      @exclusive_controllers = Array(value).map(&:to_s)
+      @compiled_exclusive_controllers = compile_patterns(@exclusive_controllers)
+    end
+
+    def exclusive_jobs=(value)
+      @exclusive_jobs = Array(value).map(&:to_s)
+      @compiled_exclusive_jobs = compile_patterns(@exclusive_jobs)
+    end
+
     # Apply a settings hash received from the backend response.
     # Only known keys are applied; unknown keys are silently ignored.
     # Serialized so concurrent HTTP threads do not interleave writes with request-thread reads.
@@ -105,45 +128,45 @@ module DeadBro
     end
 
     def excluded_controller?(controller_name, action_name = nil)
-      return false if @excluded_controllers.empty?
+      compiled = @compiled_excluded_controllers
+      return false if compiled.nil? || compiled.empty?
 
-      # If action_name is provided, check both controller#action patterns and controller-only patterns
       if action_name
         target = "#{controller_name}##{action_name}"
-        # Check controller#action patterns (patterns containing '#')
-        action_patterns = @excluded_controllers.select { |pat| pat.to_s.include?("#") }
-        if action_patterns.any? { |pat| match_name_or_pattern?(target, pat) }
-          return true
-        end
-        # Check controller-only patterns (patterns without '#')
-        # If the controller itself is excluded, all its actions are excluded
-        controller_patterns = @excluded_controllers.reject { |pat| pat.to_s.include?("#") }
-        if controller_patterns.any? { |pat| match_name_or_pattern?(controller_name, pat) }
-          return true
+        compiled.each do |entry|
+          if entry[:has_hash]
+            return true if match_compiled?(target, entry)
+          elsif match_compiled?(controller_name, entry)
+            return true
+          end
         end
         return false
       end
 
-      # When action_name is nil, only check controller-only patterns (no #)
-      controller_patterns = @excluded_controllers.reject { |pat| pat.to_s.include?("#") }
-      return false if controller_patterns.empty?
-      controller_patterns.any? { |pat| match_name_or_pattern?(controller_name, pat) }
+      compiled.each do |entry|
+        next if entry[:has_hash]
+        return true if match_compiled?(controller_name, entry)
+      end
+      false
     end
 
     def excluded_job?(job_class_name)
-      return false if @excluded_jobs.empty?
-      @excluded_jobs.any? { |pat| match_name_or_pattern?(job_class_name, pat) }
+      compiled = @compiled_excluded_jobs
+      return false if compiled.nil? || compiled.empty?
+      compiled.any? { |entry| match_compiled?(job_class_name, entry) }
     end
 
     def exclusive_job?(job_class_name)
-      return true if @exclusive_jobs.empty? # If not defined, allow all (default behavior)
-      @exclusive_jobs.any? { |pat| match_name_or_pattern?(job_class_name, pat) }
+      compiled = @compiled_exclusive_jobs
+      return true if compiled.nil? || compiled.empty?
+      compiled.any? { |entry| match_compiled?(job_class_name, entry) }
     end
 
     def exclusive_controller?(controller_name, action_name)
-      return true if @exclusive_controllers.empty? # If not defined, allow all (default behavior)
+      compiled = @compiled_exclusive_controllers
+      return true if compiled.nil? || compiled.empty?
       target = "#{controller_name}##{action_name}"
-      @exclusive_controllers.any? { |pat| match_name_or_pattern?(target, pat) }
+      compiled.any? { |entry| match_compiled?(target, entry) }
     end
 
     def should_sample?
@@ -170,21 +193,34 @@ module DeadBro
 
     private
 
-    def match_name_or_pattern?(name, pattern)
-      return false if name.nil? || pattern.nil?
-      pat = pattern.to_s
-      return !!(name.to_s == pat) unless pat.include?("*")
+    # Turn a list of user-facing patterns into {pattern, has_hash, regex}
+    # entries. Regex is nil when the pattern is a plain literal (cheaper eq
+    # compare). Compiling up-front removes per-request regex allocation.
+    def compile_patterns(patterns)
+      Array(patterns).map do |pat|
+        s = pat.to_s
+        has_hash = s.include?("#")
+        regex = if s.include?("*")
+          if has_hash
+            Regexp.new("\\A" + Regexp.escape(s).gsub("\\*", ".*") + "\\z")
+          else
+            Regexp.new("\\A" + Regexp.escape(s).gsub("\\*", "[^:]*") + "\\z")
+          end
+        end
+        {pattern: s, has_hash: has_hash, regex: regex}
+      end
+    rescue
+      []
+    end
 
-      # For controller action patterns (containing '#'), use .* to match any characters including colons
-      # For controller-only patterns, use [^:]* to match namespace segments
-      regex = if pat.include?("#")
-        # Controller action pattern: allow * to match any characters including colons
-        Regexp.new("^" + Regexp.escape(pat).gsub("\\*", ".*") + "$")
+    def match_compiled?(name, entry)
+      return false if name.nil? || entry.nil?
+      n = name.to_s
+      if entry[:regex]
+        !!(n =~ entry[:regex])
       else
-        # Controller-only pattern: use [^:]* to match namespace segments
-        Regexp.new("^" + Regexp.escape(pat).gsub("\\*", "[^:]*") + "$")
+        n == entry[:pattern]
       end
-      !!(name.to_s =~ regex)
     rescue
       false
     end

data/lib/dead_bro/dispatcher.rb

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+require "thread"
+
+module DeadBro
+  # Background worker pool that runs HTTP posts for Client off the request
+  # thread. Replaces the previous `Thread.new` per metric. One shared pool per
+  # process; re-initializes after fork (Puma, Unicorn).
+  class Dispatcher
+    DEFAULT_QUEUE_SIZE = 500
+    DEFAULT_WORKERS = 2
+    SHUTDOWN = Object.new
+
+    class << self
+      def instance
+        @instance ||= new
+      end
+
+      # Exposed for tests.
+      def reset!
+        @instance&.shutdown
+        @instance = nil
+      end
+
+      # Test hook — when true, `dispatch` runs the block inline on the caller
+      # thread instead of handing it to a worker. Keeps specs deterministic
+      # without having to stub `Thread.new` or poll for queue drain.
+      attr_accessor :inline
+    end
+
+    def initialize(queue_size: DEFAULT_QUEUE_SIZE, workers: DEFAULT_WORKERS)
+      @queue_size = queue_size
+      @worker_count = workers
+      @mutex = Mutex.new
+      @dropped = 0
+      @shutting_down = false
+      boot_workers(Process.pid)
+      install_at_exit_hook
+    end
+
+    # Schedule a block for background execution. Never blocks the caller: if the
+    # queue is full the job is dropped and `dropped_count` is incremented.
+    def dispatch(&block)
+      return false unless block_given?
+      return false if @shutting_down
+
+      if self.class.inline
+        begin
+          block.call
+        rescue
+          # Match worker semantics — swallow job errors.
+        end
+        return true
+      end
+
+      ensure_workers_alive!
+      @queue.push(block, true) # non-blocking
+      true
+    rescue ThreadError
+      @mutex.synchronize { @dropped += 1 }
+      false
+    end
+
+    def dropped_count
+      @mutex.synchronize { @dropped }
+    end
+
+    def shutdown
+      return if @shutting_down
+      @shutting_down = true
+      workers = @workers || []
+      workers.length.times do
+        begin
+          @queue.push(SHUTDOWN)
+        rescue
+        end
+      end
+      workers.each do |t|
+        begin
+          t.join(2)
+        rescue
+        end
+      end
+    end
+
+    private
+
+    def boot_workers(pid)
+      @pid = pid
+      @queue = SizedQueue.new(@queue_size)
+      @workers = Array.new(@worker_count) do
+        t = Thread.new { run }
+        begin
+          t.name = "dead_bro-dispatcher"
+        rescue
+        end
+        t.abort_on_exception = false
+        t
+      end
+    end
+
+    def ensure_workers_alive!
+      return if @pid == Process.pid && @workers && @workers.all?(&:alive?)
+
+      @mutex.synchronize do
+        return if @pid == Process.pid && @workers && @workers.all?(&:alive?)
+        # Post-fork (new PID) or a worker died — bring up a fresh pool.
+        boot_workers(Process.pid)
+        @shutting_down = false
+      end
+    end
+
+    def install_at_exit_hook
+      at_exit { shutdown }
+    rescue
+    end
+
+    def run
+      loop do
+        job = @queue.pop
+        break if job.equal?(SHUTDOWN)
+        begin
+          job.call
+        rescue
+          # Never let a job crash the worker.
+        end
+      end
+    end
+  end
+end

data/lib/dead_bro/error_middleware.rb

@@ -19,7 +19,7 @@ module DeadBro
         # Use the error class name as the event name
         event_name = exception.class.name.to_s
         event_name = EVENT_NAME if event_name.empty?
-        @client.post_metric(event_name: event_name, payload: payload)
+        @client.post_metric(event_name: event_name, payload: payload, force: true)
       rescue
         # Never let APM reporting interfere with the host app
       end

data/lib/dead_bro/job_subscriber.rb

@@ -17,15 +17,26 @@ module DeadBro
         begin
           job_class_name = data[:job].class.name
           if DeadBro.configuration.excluded_job?(job_class_name)
+            drain_job_tracking
             next
           end
           # If exclusive_jobs is defined and not empty, only track matching jobs
           unless DeadBro.configuration.exclusive_job?(job_class_name)
+            drain_job_tracking
             next
           end
         rescue
         end
 
+        # Skip out via sampling before we build any payload — jobs can be chatty
+        # enough that even the "cheap" stop/analyze work matters under load.
+        # Completions have no exception attached; the exception subscriber below
+        # always sends errors with force: true.
+        unless DeadBro.configuration.should_sample?
+          drain_job_tracking
+          next
+        end
+
         duration_ms = ((finished - started) * 1000.0).round(2)
 
         # Ensure tracking was started (fallback if perform_start.active_job didn't fire)
@@ -34,6 +45,11 @@ module DeadBro
           DeadBro.logger.clear
           Thread.current[DeadBro::TRACKING_START_TIME_KEY] = Time.now
           DeadBro::SqlSubscriber.start_request_tracking
+          if DeadBro.configuration.allocation_tracking_enabled && defined?(DeadBro::MemoryTrackingSubscriber)
+            DeadBro::MemoryTrackingSubscriber.start_request_tracking
+          else
+            DeadBro::LightweightMemoryTracker.start_request_tracking if defined?(DeadBro::LightweightMemoryTracker)
+          end
         end
 
         # Get SQL queries executed during this job
@@ -110,6 +126,11 @@ module DeadBro
           DeadBro.logger.clear
           Thread.current[DeadBro::TRACKING_START_TIME_KEY] = Time.now
           DeadBro::SqlSubscriber.start_request_tracking
+          if DeadBro.configuration.allocation_tracking_enabled && defined?(DeadBro::MemoryTrackingSubscriber)
+            DeadBro::MemoryTrackingSubscriber.start_request_tracking
+          else
+            DeadBro::LightweightMemoryTracker.start_request_tracking if defined?(DeadBro::LightweightMemoryTracker)
+          end
         end
 
         # Get SQL queries executed during this job
@@ -164,12 +185,24 @@ module DeadBro
         }
 
         event_name = exception&.class&.name || "ActiveJob::Exception"
-        client.post_metric(event_name: event_name, payload: payload, error: true)
+        client.post_metric(event_name: event_name, payload: payload, force: true)
       end
     rescue
       # Never raise from instrumentation install
     end
 
+    # Release job-side thread-local tracking state when we've decided not to
+    # build a payload (excluded job / sampled out). Matches Subscriber.drain_request_tracking.
+    def self.drain_job_tracking
+      DeadBro::SqlSubscriber.stop_request_tracking if defined?(DeadBro::SqlSubscriber)
+      DeadBro::LightweightMemoryTracker.stop_request_tracking if defined?(DeadBro::LightweightMemoryTracker)
+      if DeadBro.configuration.allocation_tracking_enabled && defined?(DeadBro::MemoryTrackingSubscriber)
+        DeadBro::MemoryTrackingSubscriber.stop_request_tracking
+      end
+    rescue
+      # Best effort
+    end
+
     private
 
     def self.safe_arguments(arguments)
@@ -215,17 +248,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/lightweight_memory_tracker.rb

@@ -43,13 +43,11 @@ module DeadBro
     end
 
     def self.lightweight_memory_usage
-      # Use only GC stats for memory estimation (no system calls)
-      return 0 unless defined?(GC) && GC.respond_to?(:stat)
-
-      gc_stats = GC.stat
-      heap_pages = gc_stats[:heap_allocated_pages] || 0
-      # Rough estimation: 4KB per page
-      (heap_pages * 4) / 1024.0 # Convert to MB
+      # Real RSS, cached for ~1s across threads so this is cheap even on hot
+      # paths. Previous versions multiplied heap_pages by 4KB and labelled the
+      # result as MB — both the unit and the page size were wrong (MRI heap
+      # pages are ~16KB and heap != RSS), so the number was effectively fiction.
+      DeadBro::MemoryHelpers.rss_mb
     rescue
       0
     end

data/lib/dead_bro/logger.rb

@@ -18,8 +18,14 @@ module DeadBro
     COLOR_ERROR = "\033[31m" # Red
     COLOR_FATAL = "\033[35m"  # Magenta
 
+    # Hard cap per-thread buffer size. Prevents unbounded growth when a
+    # request/job logs a lot, or when tracking never gets a chance to flush
+    # (e.g. code running outside a request lifecycle).
+    MAX_LOG_ENTRIES = 500
+
     def initialize
       @thread_logs_key = :dead_bro_logs
+      @thread_logs_dropped_key = :dead_bro_logs_dropped
     end
 
     def debug(message)
@@ -42,29 +48,42 @@ module DeadBro
       log(:fatal, message)
     end
 
-    # Get all logs for the current thread
+    # Get all logs for the current thread. If the buffer was capped, append a
+    # synthetic marker entry so downstream consumers know entries were dropped.
     def logs
-      Thread.current[@thread_logs_key] || []
+      entries = Thread.current[@thread_logs_key] || []
+      dropped = Thread.current[@thread_logs_dropped_key] || 0
+      return entries if dropped.zero?
+
+      entries + [{
+        sev: "warn",
+        msg: "[DeadBro::Logger] #{dropped} log entries dropped (buffer cap #{MAX_LOG_ENTRIES})",
+        time: Time.now.utc.iso8601(3)
+      }]
     end
 
     # Clear logs for the current thread
     def clear
       Thread.current[@thread_logs_key] = []
+      Thread.current[@thread_logs_dropped_key] = 0
     end
 
     private
 
     def log(severity, message)
       timestamp = Time.now.utc
-      log_entry = {
-        sev: severity.to_s,
-        msg: message.to_s,
-        time: timestamp.iso8601(3) # Include milliseconds for better precision
-      }
-
-      # Store in thread-local storage
-      Thread.current[@thread_logs_key] ||= []
-      Thread.current[@thread_logs_key] << log_entry
+
+      buffer = (Thread.current[@thread_logs_key] ||= [])
+      if buffer.length >= MAX_LOG_ENTRIES
+        Thread.current[@thread_logs_dropped_key] =
+          (Thread.current[@thread_logs_dropped_key] || 0) + 1
+      else
+        buffer << {
+          sev: severity.to_s,
+          msg: message.to_s,
+          time: timestamp.iso8601(3) # Include milliseconds for better precision
+        }
+      end
 
       # Print the message immediately
       print_log(severity, message, timestamp)

data/lib/dead_bro/memory_details.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module DeadBro
+  module MemoryDetails
+    # Maps Ruby internal ObjectSpace type codes to human-readable names.
+    # Types omitted here are filtered out (internal noise).
+    OBJECT_TYPE_NAMES = {
+      T_STRING: "String",
+      T_ARRAY: "Array",
+      T_HASH: "Hash",
+      T_OBJECT: "Object",
+      T_DATA: "C Extension",
+      T_CLASS: "Class",
+      T_MODULE: "Module",
+      T_STRUCT: "Struct",
+      T_MATCH: "MatchData",
+      T_REGEXP: "Regexp",
+      T_SYMBOL: "Symbol",
+      T_FLOAT: "Float",
+      T_FILE: "File",
+      T_BIGNUM: "Integer (big)"
+    }.freeze
+
+    # Noise types never shown to users.
+    SKIP_TYPES = %i[FREE T_IMEMO TOTAL T_NODE T_ICLASS T_ZOMBIE T_MOVED].freeze
+
+    def self.format_object_breakdown(deltas)
+      result = {}
+      deltas.each do |type, count|
+        next if SKIP_TYPES.include?(type)
+        next unless count.positive?
+        name = OBJECT_TYPE_NAMES[type] || type.to_s.sub(/\AT_/, "")
+        result[name] = count
+      end
+      result.sort_by { |_, v| -v }.to_h
+    end
+
+    def self.build(gc_before:, gc_after:, memory_before_mb:, memory_after_mb:,
+                   object_counts_before:, object_counts_after:, large_objects:)
+      memory_delta_mb = (memory_after_mb - memory_before_mb).round(2)
+      gc_collections = (gc_after[:count] || 0) - (gc_before[:count] || 0)
+      heap_pages_added = (gc_after[:heap_allocated_pages] || 0) - (gc_before[:heap_allocated_pages] || 0)
+      new_objects = (gc_after[:total_allocated_objects] || 0) - (gc_before[:total_allocated_objects] || 0)
+
+      raw_deltas = {}
+      if object_counts_before.any? && object_counts_after.any?
+        keys = (object_counts_before.keys + object_counts_after.keys).uniq
+        keys.each do |k|
+          diff = (object_counts_after[k] || 0) - (object_counts_before[k] || 0)
+          raw_deltas[k] = diff unless diff.zero?
+        end
+        raw_deltas = raw_deltas.sort_by { |_, v| -v.abs }.first(20).to_h
+      end
+
+      warnings = []
+      warnings << "Memory grew #{memory_delta_mb}MB — possible leak or large allocation" if memory_delta_mb > 20
+      warnings << "GC ran #{gc_collections} times — many short-lived objects being created" if gc_collections > 5
+      warnings << "Heap grew by #{heap_pages_added} pages — Ruby needed more memory from the OS" if heap_pages_added > 10
+      warnings << "#{large_objects.length} object(s) over 1MB found in memory" if large_objects.any?
+
+      {
+        gc_collections: gc_collections,
+        heap_pages_added: heap_pages_added,
+        new_objects: new_objects,
+        object_breakdown: format_object_breakdown(raw_deltas),
+        large_objects: large_objects,
+        warnings: warnings
+      }
+    end
+  end
+end

data/lib/dead_bro/memory_helpers.rb

@@ -4,6 +4,68 @@ module DeadBro
   module MemoryHelpers
     # Helper methods for memory tracking and leak detection
 
+    RSS_CACHE_TTL_SECONDS = 1.0
+    @rss_cache_mutex = Mutex.new
+    @rss_cache = nil # [value_bytes, captured_at_monotonic]
+
+    # Current process RSS in bytes. Uses /proc/self/status on Linux (cheap read)
+    # and falls back to `ps` elsewhere. Result is cached for 1s across threads
+    # so this is safe to call from every request without flooding the kernel.
+    def self.rss_bytes
+      now = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      cached = @rss_cache
+      if cached && (now - cached[1]) < RSS_CACHE_TTL_SECONDS
+        return cached[0]
+      end
+
+      value = read_rss_bytes
+      @rss_cache_mutex.synchronize do
+        # Re-check inside the lock to avoid racing a newer reading.
+        cached = @rss_cache
+        if cached.nil? || (now - cached[1]) >= RSS_CACHE_TTL_SECONDS
+          @rss_cache = [value, now]
+        end
+      end
+      value
+    rescue
+      0
+    end
+
+    def self.rss_mb
+      (rss_bytes.to_f / (1024 * 1024)).round(2)
+    rescue
+      0.0
+    end
+
+    def self.read_rss_bytes
+      if File.readable?("/proc/self/status")
+        read_rss_from_proc_status
+      else
+        read_rss_from_ps
+      end
+    rescue
+      0
+    end
+
+    def self.read_rss_from_proc_status
+      File.foreach("/proc/self/status") do |line|
+        next unless line.start_with?("VmRSS:")
+        kb = line.split[1].to_i
+        return kb * 1024 if kb > 0
+      end
+      0
+    rescue
+      0
+    end
+
+    def self.read_rss_from_ps
+      kb = `ps -o rss= -p #{Process.pid}`.to_i
+      return 0 if kb <= 0
+      kb * 1024
+    rescue
+      0
+    end
+
     # Take a memory snapshot with a custom label
     def self.snapshot(label)
       DeadBro::MemoryTrackingSubscriber.take_memory_snapshot(label)