dead_bro 0.2.8 → 0.2.10

data/lib/dead_bro/client.rb

@@ -12,30 +12,21 @@ module DeadBro
       @circuit_breaker = create_circuit_breaker
     end
 
-    def post_metric(event_name:, payload:)
+    def post_metric(event_name:, payload:, force: false)
       return if @configuration.api_key.nil?
       return unless @configuration.enabled
+      return if !force && !@configuration.should_sample?
+      return if circuit_open?
 
-      # Check sampling rate - skip if not selected for sampling
-      return unless @configuration.should_sample?
-
-      # 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
-
-      # Truncate large arrays to avoid 413 Request Entity Too Large
       payload = truncate_payload_for_request(payload)
+      body = {event: event_name, payload: payload, sent_at: Time.now.utc.iso8601, revision: @configuration.resolve_deploy_id}
 
-      # Make the HTTP request (async)
-      make_http_request(event_name, payload, @configuration.api_key)
+      dispatch_request(
+        url: metrics_endpoint_url,
+        body: body,
+        event_name: event_name,
+        apply_settings: true
+      )
 
       nil
     end
@@ -44,7 +35,15 @@ module DeadBro
       return if @configuration.api_key.nil?
 
       @configuration.last_heartbeat_attempt_at = Time.now.utc
-      make_http_request("heartbeat", {}, @configuration.api_key)
+      body = {event: "heartbeat", payload: {}, sent_at: Time.now.utc.iso8601, revision: @configuration.resolve_deploy_id}
+
+      dispatch_request(
+        url: metrics_endpoint_url,
+        body: body,
+        event_name: "heartbeat",
+        apply_settings: true
+      )
+
       nil
     end
 
@@ -52,27 +51,108 @@ module DeadBro
       return if @configuration.api_key.nil?
       return unless @configuration.enabled
       return unless @configuration.job_queue_monitoring_enabled
+      return if circuit_open?
+
+      body = {payload: payload, sent_at: Time.now.utc.iso8601, revision: @configuration.resolve_deploy_id}
+
+      dispatch_request(
+        url: monitor_endpoint_url,
+        body: body,
+        event_name: nil,
+        apply_settings: false
+      )
+
+      nil
+    end
+
+    private
+
+    # Returns true (and short-circuits) when the circuit is open and not ready
+    # to probe. Transitions to HALF_OPEN when the recovery timeout has elapsed.
+    def circuit_open?
+      return false unless @circuit_breaker && @configuration.circuit_breaker_enabled
+      return false unless @circuit_breaker.state == :open
+
+      if @circuit_breaker.should_attempt_reset?
+        @circuit_breaker.transition_to_half_open!
+        false
+      else
+        true
+      end
+    end
+
+    def metrics_endpoint_url
+      if @configuration.ruby_dev
+        "http://localhost:3100/apm/v1/metrics"
+      elsif ENV["USE_STAGING_ENDPOINT"] && !ENV["USE_STAGING_ENDPOINT"].empty?
+        "https://deadbro.aberatii.com/apm/v1/metrics"
+      else
+        "https://www.deadbro.com/apm/v1/metrics"
+      end
+    end
 
-      # 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!
+    def monitor_endpoint_url
+      if @configuration.ruby_dev
+        "http://localhost:3100/apm/v1/monitor"
+      elsif ENV["USE_STAGING_ENDPOINT"] && !ENV["USE_STAGING_ENDPOINT"].empty?
+        "https://deadbro.aberatii.com/apm/v1/monitor"
+      else
+        "https://www.deadbro.com/apm/v1/monitor"
+      end
+    end
+
+    def dispatch_request(url:, body:, event_name:, apply_settings: false)
+      uri = URI.parse(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 #{@configuration.api_key}"
+      if @configuration.settings_received_at
+        request["X-Settings-Received-At"] = @configuration.settings_received_at.utc.iso8601
+      end
+      request.body = JSON.dump(body)
+
+      DeadBro::Dispatcher.instance.dispatch do
+        perform_request(http, request, event_name: event_name, apply_settings: apply_settings)
+      end
+    end
+
+    def perform_request(http, request, event_name:, apply_settings: false)
+      response = http.request(request)
+
+      if response
+        if @circuit_breaker && @configuration.circuit_breaker_enabled
+          if response.is_a?(Net::HTTPSuccess)
+            @circuit_breaker.record_success
           else
-            return
+            @circuit_breaker.record_failure
           end
         end
-      end
 
-      # Make the HTTP request (async) to jobs endpoint
-      make_monitor_request(payload, @configuration.api_key)
+        if apply_settings
+          apply_settings_from_response(response)
+
+          if response.is_a?(Net::HTTPSuccess) && event_name == "heartbeat"
+            @configuration.last_heartbeat_at = Time.now.utc
+          end
+        end
+      elsif @circuit_breaker && @configuration.circuit_breaker_enabled
+        @circuit_breaker.record_failure
+      end
 
+      response
+    rescue Timeout::Error
+      @circuit_breaker&.record_failure if @configuration.circuit_breaker_enabled
+      nil
+    rescue
+      @circuit_breaker&.record_failure if @configuration.circuit_breaker_enabled
       nil
     end
 
-    private
-
     def apply_settings_from_response(response)
       return unless response.is_a?(Net::HTTPSuccess)
 
@@ -87,7 +167,6 @@ module DeadBro
       # 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)
 
@@ -119,116 +198,6 @@ module DeadBro
       )
     end
 
-    def make_http_request(event_name, payload, api_key)
-      use_staging = ENV["USE_STAGING_ENDPOINT"] && !ENV["USE_STAGING_ENDPOINT"].empty?
-      production_url = use_staging ? "https://deadbro.aberatii.com/apm/v1/metrics" : "https://www.deadbro.com/apm/v1/metrics"
-      endpoint_url = @configuration.ruby_dev ? "http://localhost:3100/apm/v1/metrics" : 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}"
-      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)
-
-      # Fire-and-forget using a short-lived thread to avoid blocking the request cycle.
-      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
-
-          # 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)
-        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 make_monitor_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/monitor" : "https://www.deadbro.com/apm/v1/monitor"
-      endpoint_url = @configuration.ruby_dev ? "http://localhost:3100/apm/v1/monitor" : 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

@@ -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