dead_bro 0.2.6 → 0.2.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7e977f41766dfbcf7ca52cf14aafb217595f35860746a553bd9386b1ddfe7797
-  data.tar.gz: 24858e179f45181d6d144352347ed3f760a19abe53cead83c80eb4644e281f39
+  metadata.gz: 7d8e1d14cc8e5511d143de228afefcb1a7557b8ce0308b7302ba40f4bc78bc90
+  data.tar.gz: 1d215f5ff69110be5c10e965bcf2ac2f08f1f6cb9a2be72b602f143c3e3ac5e5
 SHA512:
-  metadata.gz: 7310571657927f6404088b2605d710cb9e107d5e63231cddcf785ffc9cc22a78ff634d5bc5969e34d08e634ed0cdc46f85f8f2d6937bc05ebe9af14b00c4968c
-  data.tar.gz: eaaec05db2cdf1d2da03cfa873c333286d891e33cb2e37d6b347b319a3ae8481f142182d87c3ce20bd2990829075aa236e52c9f52388d2799fc862b1511ceabd
+  metadata.gz: 9cab5ed48ea05f086512683b1d8d9fdb05030328f4fb4cb908884f074bc23b361ba7914774106bb5f1eba511435cdb506b123b2c4d2ece41634b539e925576a9
+  data.tar.gz: '0695e7e7bc6f5835fde69586aa2bc03c134ca9a2515a4bda4e55a0c78242f776315e07018834a2ce66c9a828849c05d807c38e183f99ab77e00ac4d239144943'

data/lib/dead_bro/client.rb

@@ -31,12 +31,23 @@ module DeadBro
         end
       end
 
+      # Truncate large arrays to avoid 413 Request Entity Too Large
+      payload = truncate_payload_for_request(payload)
+
       # Make the HTTP request (async)
       make_http_request(event_name, payload, @configuration.api_key)
 
       nil
     end
 
+    def post_heartbeat
+      return if @configuration.api_key.nil?
+
+      @configuration.last_heartbeat_attempt_at = Time.now.utc
+      make_http_request("heartbeat", {}, @configuration.api_key)
+      nil
+    end
+
     def post_monitor_stats(payload)
       return if @configuration.api_key.nil?
       return unless @configuration.enabled
@@ -62,6 +73,42 @@ module DeadBro
 
     private
 
+    def apply_settings_from_response(response)
+      return unless response.is_a?(Net::HTTPSuccess)
+
+      body = JSON.parse(response.body)
+      return unless body.is_a?(Hash) && body["settings"].is_a?(Hash)
+
+      @configuration.apply_remote_settings(body["settings"])
+
+      updated_at_str = body["settings_updated_at"]
+      @configuration.settings_received_at = updated_at_str ? Time.iso8601(updated_at_str) : Time.now.utc
+    rescue JSON::ParserError, ArgumentError
+      # Malformed response — ignore, settings stay as-is
+    end
+
+    # Limit payload size to avoid 413 from nginx/reverse proxies. Returns a new hash.
+    def truncate_payload_for_request(payload)
+      return payload unless payload.is_a?(Hash)
+
+      max_sql = @configuration.max_sql_queries_to_send
+      max_logs = @configuration.max_logs_to_send
+
+      out = payload.dup
+
+      if out.key?(:sql_queries) && out[:sql_queries].is_a?(Array) && out[:sql_queries].size > max_sql
+        out[:sql_queries_total_count] = out[:sql_queries].size
+        out[:sql_queries] = out[:sql_queries].first(max_sql)
+      end
+
+      if out.key?(:logs) && out[:logs].is_a?(Array) && out[:logs].size > max_logs
+        out[:logs_total_count] = out[:logs].size
+        out[:logs] = out[:logs].first(max_logs)
+      end
+
+      out
+    end
+
     def create_circuit_breaker
       return nil unless @configuration.circuit_breaker_enabled
 
@@ -85,6 +132,9 @@ module DeadBro
       request = Net::HTTP::Post.new(uri.request_uri)
       request["Content-Type"] = "application/json"
       request["Authorization"] = "Bearer #{api_key}"
+      if @configuration.settings_received_at
+        request["X-Settings-Received-At"] = @configuration.settings_received_at.utc.iso8601
+      end
       body = {event: event_name, payload: payload, sent_at: Time.now.utc.iso8601, revision: @configuration.resolve_deploy_id}
       request.body = JSON.dump(body)
 
@@ -101,6 +151,13 @@ module DeadBro
               @circuit_breaker.send(:on_failure)
             end
           end
+
+          # Apply remote settings if the backend included them in the response
+          apply_settings_from_response(response)
+
+          if response.is_a?(Net::HTTPSuccess) && event_name == "heartbeat"
+            @configuration.last_heartbeat_at = Time.now.utc
+          end
         elsif @circuit_breaker && @configuration.circuit_breaker_enabled
           # Treat nil response as failure for circuit breaker
           @circuit_breaker.send(:on_failure)

data/lib/dead_bro/configuration.rb

@@ -2,40 +2,102 @@
 
 module DeadBro
   class Configuration
-    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,
+    # Local-only settings (not overwritten by API `settings` payloads).
+    # Note: `enabled` may still be updated remotely via apply_remote_settings when the backend
+    # returns it in a response; local configure() values apply until the next remote update.
+    attr_accessor :api_key, :open_timeout, :read_timeout, :enabled, :ruby_dev,
+      :circuit_breaker_enabled, :circuit_breaker_failure_threshold, :circuit_breaker_recovery_timeout,
+      :circuit_breaker_retry_timeout, :deploy_id, :disk_paths, :interfaces_ignore
+
+    # 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,
       :job_queue_monitoring_enabled, :enable_db_stats, :enable_process_stats, :enable_system_stats,
-      :disk_paths, :interfaces_ignore
+      :max_sql_queries_to_send, :max_logs_to_send
+
+    # Tracks when we last received settings from the backend (in-memory only)
+    attr_accessor :settings_received_at
+
+    # Last successful heartbeat HTTP response time while disabled (in-memory only)
+    attr_accessor :last_heartbeat_at
+
+    # Throttles heartbeat attempts to HEARTBEAT_INTERVAL (set when a heartbeat request is started)
+    attr_accessor :last_heartbeat_attempt_at
+
+    HEARTBEAT_INTERVAL = 60 # seconds
+
+    REMOTE_SETTING_KEYS = %w[
+      enabled sample_rate memory_tracking_enabled allocation_tracking_enabled
+      explain_analyze_enabled slow_query_threshold_ms max_sql_queries_to_send max_logs_to_send
+      excluded_controllers excluded_jobs exclusive_controllers exclusive_jobs
+      job_queue_monitoring_enabled enable_db_stats enable_process_stats enable_system_stats
+    ].freeze
 
     def initialize
       @api_key = nil
-      @endpoint_url = nil
       @open_timeout = 1.0
       @read_timeout = 1.0
       @enabled = true
       @ruby_dev = false
-      @memory_tracking_enabled = true
-      @allocation_tracking_enabled = false # Disabled by default for performance
       @circuit_breaker_enabled = true
       @circuit_breaker_failure_threshold = 3
-      @circuit_breaker_recovery_timeout = 60 # seconds
-      @circuit_breaker_retry_timeout = 300 # seconds
+      @circuit_breaker_recovery_timeout = 60
+      @circuit_breaker_retry_timeout = 300
+      @deploy_id = resolve_deploy_id
+      @disk_paths = ["/"]
+      @interfaces_ignore = %w[lo lo0 docker0]
+
+      # Remote-managed defaults (used until backend sends real values)
       @sample_rate = 100
+      @memory_tracking_enabled = true
+      @allocation_tracking_enabled = false
+      @explain_analyze_enabled = false
+      @slow_query_threshold_ms = 500
+      @max_sql_queries_to_send = 500
+      @max_logs_to_send = 100
       @excluded_controllers = []
       @excluded_jobs = []
       @exclusive_controllers = []
       @exclusive_jobs = []
-      @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
+      @job_queue_monitoring_enabled = false
       @enable_db_stats = false
       @enable_process_stats = false
       @enable_system_stats = false
-      @disk_paths = ["/"]
-      @interfaces_ignore = %w[lo lo0 docker0]
+
+      @settings_received_at = nil
+      @last_heartbeat_at = nil
+      @last_heartbeat_attempt_at = nil
+      @settings_mutex = Mutex.new
+    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.
+    def apply_remote_settings(hash)
+      return unless hash.is_a?(Hash)
+
+      @settings_mutex.synchronize do
+        hash.each do |key, value|
+          k = key.to_s
+          next unless REMOTE_SETTING_KEYS.include?(k)
+
+          case k
+          when "sample_rate", "slow_query_threshold_ms", "max_sql_queries_to_send", "max_logs_to_send"
+            send(:"#{k}=", value.to_i)
+          when "enabled", "memory_tracking_enabled", "allocation_tracking_enabled", "explain_analyze_enabled",
+               "job_queue_monitoring_enabled", "enable_db_stats", "enable_process_stats", "enable_system_stats"
+            send(:"#{k}=", !!value)
+          when "excluded_controllers", "excluded_jobs", "exclusive_controllers", "exclusive_jobs"
+            send(:"#{k}=", Array(value).map(&:to_s))
+          end
+        end
+      end
+    end
+
+    def heartbeat_due?
+      return false if api_key.nil?
+      last_heartbeat_attempt_at.nil? || (Time.now.utc - last_heartbeat_attempt_at) >= HEARTBEAT_INTERVAL
     end
 
     def resolve_deploy_id
@@ -86,6 +148,8 @@ module DeadBro
 
     def should_sample?
       sample_rate = resolve_sample_rate
+      sample_rate = 100 if sample_rate.nil?
+
       return true if sample_rate >= 100
       return false if sample_rate <= 0
 
@@ -93,22 +157,9 @@ module DeadBro
       rand(1..100) <= sample_rate
     end
 
+    # Returns the configured sample_rate only (no ENV fallback). Use DeadBro.configure or remote settings.
     def resolve_sample_rate
-      return @sample_rate unless @sample_rate.nil?
-
-      if ENV["dead_bro_SAMPLE_RATE"]
-        env_value = ENV["dead_bro_SAMPLE_RATE"].to_s.strip
-        # Validate that it's a valid integer string
-        if env_value.match?(/^\d+$/)
-          parsed = env_value.to_i
-          # Ensure it's in valid range (0-100)
-          (parsed >= 0 && parsed <= 100) ? parsed : 100
-        else
-          100 # Invalid format, fall back to default
-        end
-      else
-        100 # default
-      end
+      @sample_rate
     end
 
     def resolve_api_key
@@ -117,17 +168,6 @@ module DeadBro
       ENV["DEAD_BRO_API_KEY"]
     end
 
-    def sample_rate=(value)
-      # Allow nil to use default/resolved value
-      return @sample_rate = nil if value.nil?
-
-      # Allow 0 to disable sampling, or 1-100 for percentage
-      unless value.is_a?(Integer) && value >= 0 && value <= 100
-        raise ArgumentError, "Sample rate must be an integer between 0 and 100, got: #{value.inspect}"
-      end
-      @sample_rate = value
-    end
-
     private
 
     def match_name_or_pattern?(name, pattern)

data/lib/dead_bro/job_subscriber.rb

@@ -30,7 +30,7 @@ module DeadBro
 
         # 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]
+        unless DeadBro::SqlSubscriber.tracking_active?
           DeadBro.logger.clear
           Thread.current[DeadBro::TRACKING_START_TIME_KEY] = Time.now
           DeadBro::SqlSubscriber.start_request_tracking
@@ -103,10 +103,10 @@ module DeadBro
 
         duration_ms = ((finished - started) * 1000.0).round(2)
         exception = data[:exception_object]
+        data[:job].class.name
 
         # 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]
+        unless DeadBro::SqlSubscriber.tracking_active?
           DeadBro.logger.clear
           Thread.current[DeadBro::TRACKING_START_TIME_KEY] = Time.now
           DeadBro::SqlSubscriber.start_request_tracking

data/lib/dead_bro/lightweight_memory_tracker.rb

@@ -8,19 +8,25 @@ module DeadBro
     def self.start_request_tracking
       return unless DeadBro.configuration.memory_tracking_enabled
 
-      # Only track essential metrics to minimize overhead
-      Thread.current[THREAD_LOCAL_KEY] = {
+      # Stack allows nested job tracking (e.g. one job performing others in the same thread)
+      mem_before = lightweight_memory_usage
+      frame = {
         gc_before: lightweight_gc_stats,
-        memory_before: lightweight_memory_usage,
+        memory_before: mem_before,
         start_time: Process.clock_gettime(Process::CLOCK_MONOTONIC)
       }
+      (Thread.current[THREAD_LOCAL_KEY] ||= []) << frame
     end
 
     def self.stop_request_tracking
-      events = Thread.current[THREAD_LOCAL_KEY]
-      Thread.current[THREAD_LOCAL_KEY] = nil
+      stack = Thread.current[THREAD_LOCAL_KEY]
+      unless stack.is_a?(Array) && stack.any?
+        Thread.current[THREAD_LOCAL_KEY] = nil
+        return {}
+      end
 
-      return {} unless events
+      events = stack.pop
+      Thread.current[THREAD_LOCAL_KEY] = nil if stack.empty?
 
       # Calculate only essential metrics
       gc_after = lightweight_gc_stats

data/lib/dead_bro/memory_tracking_subscriber.rb

@@ -54,11 +54,18 @@ module DeadBro
       # Never raise from instrumentation install
     end
 
+    # Current frame (top of stack) for nested job tracking; nil if none.
+    def self.current_events
+      stack = Thread.current[THREAD_LOCAL_KEY]
+      return nil unless stack.is_a?(Array) && stack.any?
+      stack.last
+    end
+
     def self.start_request_tracking
       # Only track if memory tracking is enabled
       return unless DeadBro.configuration.memory_tracking_enabled
 
-      Thread.current[THREAD_LOCAL_KEY] = {
+      frame = {
         allocations: [],
         memory_snapshots: [],
         large_objects: [],
@@ -68,11 +75,13 @@ module DeadBro
         start_time: Time.now.to_f,
         object_counts_before: count_objects_snapshot
       }
+      (Thread.current[THREAD_LOCAL_KEY] ||= []) << frame
     end
 
     def self.stop_request_tracking
-      events = Thread.current[THREAD_LOCAL_KEY]
-      Thread.current[THREAD_LOCAL_KEY] = nil
+      stack = Thread.current[THREAD_LOCAL_KEY]
+      events = (stack.is_a?(Array) && stack.any?) ? stack.pop : nil
+      Thread.current[THREAD_LOCAL_KEY] = nil if stack.nil? || stack.empty?
 
       if events
         events[:gc_after] = gc_stats
@@ -92,22 +101,24 @@ module DeadBro
 
     # Record request-level allocation counters from Rails instrumentation.
     def self.record_request_allocations(allocations:, allocated_bytes:)
-      return unless Thread.current[THREAD_LOCAL_KEY]
+      events = current_events
+      return unless events
 
-      Thread.current[THREAD_LOCAL_KEY][:request_allocations] = {
+      events[:request_allocations] = {
         allocations: allocations,
         allocated_bytes: allocated_bytes
       }
     end
 
     def self.track_allocation(data, started, finished)
-      return unless Thread.current[THREAD_LOCAL_KEY]
+      events = current_events
+      return unless events
 
       # Only track if we have meaningful allocation data
       return unless data.is_a?(Hash) && data[:count] && data[:size]
 
       # Limit allocations per request to prevent memory bloat
-      allocations = Thread.current[THREAD_LOCAL_KEY][:allocations]
+      allocations = events[:allocations]
       return if allocations.length >= MAX_ALLOCATIONS_PER_REQUEST
 
       # Simplified allocation tracking (avoid expensive operations)
@@ -124,14 +135,15 @@ module DeadBro
           large_object: true,
           size_mb: (data[:size] / 1_000_000.0).round(2)
         )
-        Thread.current[THREAD_LOCAL_KEY][:large_objects] << large_object
+        events[:large_objects] << large_object
       end
 
-      Thread.current[THREAD_LOCAL_KEY][:allocations] << allocation
+      events[:allocations] << allocation
     end
 
     def self.take_memory_snapshot(label = nil)
-      return unless Thread.current[THREAD_LOCAL_KEY]
+      events = current_events
+      return unless events
 
       snapshot = {
         label: label || "snapshot_#{Time.now.to_i}",
@@ -142,7 +154,7 @@ module DeadBro
         heap_pages: heap_pages
       }
 
-      Thread.current[THREAD_LOCAL_KEY][:memory_snapshots] << snapshot
+      events[:memory_snapshots] << snapshot
     end
 
     def self.analyze_memory_performance(memory_events)
@@ -179,10 +191,10 @@ module DeadBro
       # Group allocations by class
       allocations_by_class = allocations.group_by { |a| a[:class_name] }
         .transform_values { |allocs|
-        {
-          count: allocs.sum { |a| a[:count] },
-          size: allocs.sum { |a| a[:size] }
-        }
+          {
+            count: allocs.sum { |a| a[:count] },
+            size: allocs.sum { |a| a[:size] }
+          }
       }
 
       # Find top allocating classes

data/lib/dead_bro/redis_subscriber.rb

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

data/lib/dead_bro/sql_subscriber.rb

@@ -16,13 +16,25 @@ module DeadBro
     THREAD_LOCAL_EXPLAIN_PENDING_KEY = :dead_bro_explain_pending
     MAX_TRACKED_QUERIES = 1000
 
+    # True when there is at least one active tracking context (e.g. for nested jobs).
+    def self.tracking_active?
+      stack = Thread.current[THREAD_LOCAL_KEY]
+      stack.is_a?(Array) && stack.any?
+    end
+
+    # Current queries array (top of stack); nil if no active tracking.
+    def self.current_queries_array
+      stack = Thread.current[THREAD_LOCAL_KEY]
+      return nil unless stack.is_a?(Array) && stack.any?
+      stack.last
+    end
+
     # 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
+    def self.should_continue_tracking?(current_queries_array, max_count)
+      return false unless current_queries_array.is_a?(Array)
 
       # Check count limit
-      return false if events.length >= max_count
+      return false if current_queries_array.length >= max_count
 
       # Check time limit
       start_time = Thread.current[DeadBro::TRACKING_START_TIME_KEY]
@@ -44,9 +56,10 @@ module DeadBro
       end
 
       ActiveSupport::Notifications.subscribe(SQL_EVENT_NAME) do |name, started, finished, _unique_id, data|
-        next if data[:name] == "SCHEMA"
-        # Only track queries that are part of the current request
-        next unless Thread.current[THREAD_LOCAL_KEY]
+        next if data[:name] == "SCHEMA" || data[:name] == "CACHE" || data[:name] == "BEGIN" || data[:name] == "COMMIT" || data[:name] == "ROLLBACK" || data[:name] == "SAVEPOINT" || data[:name] == "RELEASE"
+        # Only track queries that are part of the current request (top of stack for nested jobs)
+        current = current_queries_array
+        next unless current
         unique_id = _unique_id
         allocations = nil
         captured_backtrace = nil
@@ -82,15 +95,16 @@ module DeadBro
           start_explain_analyze_background(original_sql, data[:connection_id], query_info, binds)
         end
 
-        # 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
+        # Add to current context (top of stack), but only if we haven't exceeded the limits
+        if should_continue_tracking?(current, MAX_TRACKED_QUERIES)
+          current << query_info
         end
       end
     end
 
     def self.start_request_tracking
-      Thread.current[THREAD_LOCAL_KEY] = []
+      # Stack allows nested job tracking (e.g. one job performing others in the same thread)
+      (Thread.current[THREAD_LOCAL_KEY] ||= []) << []
       Thread.current[THREAD_LOCAL_ALLOC_START_KEY] = {}
       Thread.current[THREAD_LOCAL_ALLOC_RESULTS_KEY] = {}
       Thread.current[THREAD_LOCAL_BACKTRACE_KEY] = {}
@@ -103,15 +117,17 @@ module DeadBro
       # all explain_plan fields are populated
       wait_for_pending_explains(5.0) # 5 second timeout
 
-      # Get queries after waiting for EXPLAIN to complete
-      queries = Thread.current[THREAD_LOCAL_KEY]
-
-      Thread.current[THREAD_LOCAL_KEY] = nil
-      Thread.current[THREAD_LOCAL_ALLOC_START_KEY] = nil
-      Thread.current[THREAD_LOCAL_ALLOC_RESULTS_KEY] = nil
-      Thread.current[THREAD_LOCAL_BACKTRACE_KEY] = nil
-      Thread.current[THREAD_LOCAL_EXPLAIN_PENDING_KEY] = nil
-      queries || []
+      stack = Thread.current[THREAD_LOCAL_KEY]
+      queries = (stack.is_a?(Array) && stack.any?) ? stack.pop : []
+      # Clear thread locals when stack is empty so "tracking not started" behaves correctly
+      if stack.nil? || stack.empty?
+        Thread.current[THREAD_LOCAL_KEY] = nil
+        Thread.current[THREAD_LOCAL_ALLOC_START_KEY] = nil
+        Thread.current[THREAD_LOCAL_ALLOC_RESULTS_KEY] = nil
+        Thread.current[THREAD_LOCAL_BACKTRACE_KEY] = nil
+        Thread.current[THREAD_LOCAL_EXPLAIN_PENDING_KEY] = nil
+      end
+      queries
     end
 
     def self.wait_for_pending_explains(timeout_seconds)

data/lib/dead_bro/subscriber.rb

@@ -8,21 +8,23 @@ module DeadBro
 
     def self.subscribe!(client: Client.new)
       ActiveSupport::Notifications.subscribe(EVENT_NAME) do |name, started, finished, _unique_id, data|
+        # When disabled remotely, fire a heartbeat at most once per minute so the gem
+        # can detect when tracking has been re-enabled, then skip all tracking.
+        unless DeadBro.configuration.enabled
+          client.post_heartbeat if DeadBro.configuration.heartbeat_due?
+          next
+        end
+
         # Skip excluded controllers or controller#action pairs
         # Also check exclusive_controller_actions - if defined, only track those
+        notification = data.is_a?(Hash) ? data : {}
+        controller_name = notification[:controller].to_s
+        action_name = notification[:action].to_s
         begin
-          controller_name = data[:controller].to_s
-          action_name = data[:action].to_s
-          if DeadBro.configuration.excluded_controller?(controller_name, action_name)
-            puts "excluded controller"
-            next
-          end
-          # If exclusive_controller_actions is defined and not empty, only track matching actions
-          unless DeadBro.configuration.exclusive_controller?(controller_name, action_name)
-            puts "exclusive controller"
-            next
-          end
+          next if DeadBro.configuration.excluded_controller?(controller_name, action_name)
+          next unless DeadBro.configuration.exclusive_controller?(controller_name, action_name)
         rescue
+          next
         end
 
         duration_ms = ((finished - started) * 1000.0).round(2)

data/lib/dead_bro/version.rb

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

data/lib/dead_bro.rb

@@ -120,7 +120,7 @@ module DeadBro
 
     begin
       if defined?(DeadBro::MemoryTrackingSubscriber) &&
-         !Thread.current[DeadBro::MemoryTrackingSubscriber::THREAD_LOCAL_KEY]
+          !Thread.current[DeadBro::MemoryTrackingSubscriber::THREAD_LOCAL_KEY]
         DeadBro::MemoryTrackingSubscriber.start_request_tracking
         memory_tracking_started = true
       end
@@ -128,10 +128,10 @@ module DeadBro
     end
 
     begin
-      if defined?(DeadBro::MemoryTrackingSubscriber)
-        memory_before_mb = DeadBro::MemoryTrackingSubscriber.memory_usage_mb
+      memory_before_mb = if defined?(DeadBro::MemoryTrackingSubscriber)
+        DeadBro::MemoryTrackingSubscriber.memory_usage_mb
       else
-        memory_before_mb = 0.0
+        0.0
       end
     rescue
       memory_before_mb = 0.0
@@ -148,7 +148,6 @@ module DeadBro
     begin
       if defined?(ActiveSupport) && defined?(ActiveSupport::Notifications)
         # Ensure SqlSubscriber is loaded so SQL_EVENT_NAME is defined
-        DeadBro::SqlSubscriber
         event_name = DeadBro::SqlSubscriber::SQL_EVENT_NAME
 
         sql_notification_subscription =
@@ -197,11 +196,9 @@ module DeadBro
     block_start = Process.clock_gettime(Process::CLOCK_MONOTONIC)
 
     error = nil
-    result = nil
-    analysis_result = nil
 
     begin
-      result = yield
+      yield
     rescue => e
       error = e
     ensure
@@ -225,7 +222,7 @@ module DeadBro
       sql_time_ms = local_sql_queries.sum { |q| (q[:duration_ms] || 0.0).to_f }.round(2)
 
       # Group SQL queries by normalized pattern to show frequency and cost
-      query_signatures = Hash.new { |h, k| h[k] = { count: 0, total_time_ms: 0.0, type: nil } }
+      query_signatures = Hash.new { |h, k| h[k] = {count: 0, total_time_ms: 0.0, type: nil} }
       local_sql_queries.each do |q|
         sig = (q[:sql] || "UNKNOWN").to_s
         entry = query_signatures[sig]
@@ -237,7 +234,6 @@ module DeadBro
       top_query_signatures = query_signatures.sort_by { |_, data| -data[:count] }.first(3)
 
       memory_after_mb = memory_before_mb
-      memory_delta_mb = 0.0
       detailed_memory_summary = nil
 
       raw_events = {}
@@ -255,14 +251,12 @@ module DeadBro
           memory_before_mb = raw_events[:memory_before]
         end
 
-        if raw_events[:memory_after]
-          memory_after_mb = raw_events[:memory_after]
+        memory_after_mb = if raw_events[:memory_after]
+          raw_events[:memory_after]
+        elsif defined?(DeadBro::MemoryTrackingSubscriber)
+          DeadBro::MemoryTrackingSubscriber.memory_usage_mb
         else
-          if defined?(DeadBro::MemoryTrackingSubscriber)
-            memory_after_mb = DeadBro::MemoryTrackingSubscriber.memory_usage_mb
-          else
-            memory_after_mb = memory_before_mb
-          end
+          memory_before_mb
         end
       rescue
         memory_after_mb = memory_before_mb

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: dead_bro
 version: !ruby/object:Gem::Version
-  version: 0.2.6
+  version: 0.2.8
 platform: ruby
 authors:
 - Emanuel Comsa
@@ -69,7 +69,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.3
+rubygems_version: 4.0.9
 specification_version: 4
 summary: Minimal APM for Rails apps.
 test_files: []