dead_bro 0.2.7 → 0.2.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9a78b3a99d00159acb1bf2fd97a0eed54ba0e03a24d7bbd2ec840e4bf779107f
-  data.tar.gz: 53aba3dcf00e53f210020529413561812de25b3399db8ce040b9976ab798e8d1
+  metadata.gz: 7d8e1d14cc8e5511d143de228afefcb1a7557b8ce0308b7302ba40f4bc78bc90
+  data.tar.gz: 1d215f5ff69110be5c10e965bcf2ac2f08f1f6cb9a2be72b602f143c3e3ac5e5
 SHA512:
-  metadata.gz: c150a7a452b46c4a600afbccb4a520a2f52b0c0bb3a85fec8f0a41f0ece56ea5161575a30a15002c18a8fa2b82e5692ccf13e49920ea3fffc031f7d23188027b
-  data.tar.gz: 22b3ea56482f38005ccbd98eae13be751fade782a69f355573ccd49fb2524e3f9bd2c9e40128df5bbb0c2e521924d7f8cba2c49c41a88ad67efafb6041c2f50d
+  metadata.gz: 9cab5ed48ea05f086512683b1d8d9fdb05030328f4fb4cb908884f074bc23b361ba7914774106bb5f1eba511435cdb506b123b2c4d2ece41634b539e925576a9
+  data.tar.gz: '0695e7e7bc6f5835fde69586aa2bc03c134ca9a2515a4bda4e55a0c78242f776315e07018834a2ce66c9a828849c05d807c38e183f99ab77e00ac4d239144943'

data/lib/dead_bro/client.rb

@@ -40,6 +40,14 @@ module DeadBro
       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
@@ -65,12 +73,26 @@ 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.respond_to?(:max_sql_queries_to_send) ? @configuration.max_sql_queries_to_send : 500
-      max_logs = @configuration.respond_to?(:max_logs_to_send) ? @configuration.max_logs_to_send : 100
+      max_sql = @configuration.max_sql_queries_to_send
+      max_logs = @configuration.max_logs_to_send
 
       out = payload.dup
 
@@ -110,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)
 
@@ -126,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,42 +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
+      :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]
-      @max_sql_queries_to_send = 500 # Cap to avoid 413 Request Entity Too Large
-      @max_logs_to_send = 100
+
+      @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
@@ -88,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
 
@@ -95,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
@@ -119,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

@@ -103,7 +103,7 @@ module DeadBro
 
         duration_ms = ((finished - started) * 1000.0).round(2)
         exception = data[:exception_object]
-        job_class = data[:job].class.name
+        data[:job].class.name
 
         # Ensure tracking was started (fallback if perform_start.active_job didn't fire)
         unless DeadBro::SqlSubscriber.tracking_active?

data/lib/dead_bro/memory_tracking_subscriber.rb

@@ -80,7 +80,7 @@ module DeadBro
 
     def self.stop_request_tracking
       stack = Thread.current[THREAD_LOCAL_KEY]
-      events = stack.is_a?(Array) && stack.any? ? stack.pop : nil
+      events = (stack.is_a?(Array) && stack.any?) ? stack.pop : nil
       Thread.current[THREAD_LOCAL_KEY] = nil if stack.nil? || stack.empty?
 
       if events
@@ -191,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

@@ -118,7 +118,7 @@ module DeadBro
       wait_for_pending_explains(5.0) # 5 second timeout
 
       stack = Thread.current[THREAD_LOCAL_KEY]
-      queries = stack.is_a?(Array) && stack.any? ? stack.pop : []
+      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

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.7"
+  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.7
+  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: []