dead_bro 0.2.0

data/lib/dead_bro/cache_subscriber.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+require "active_support/notifications"
+
+module DeadBro
+  class CacheSubscriber
+    THREAD_LOCAL_KEY = :dead_bro_cache_events
+
+    EVENTS = [
+      "cache_read.active_support",
+      "cache_write.active_support",
+      "cache_delete.active_support",
+      "cache_exist?.active_support",
+      "cache_fetch_hit.active_support",
+      "cache_generate.active_support",
+      "cache_read_multi.active_support",
+      "cache_write_multi.active_support"
+    ].freeze
+
+    def self.subscribe!
+      EVENTS.each do |event_name|
+        ActiveSupport::Notifications.subscribe(event_name) do |name, started, finished, _unique_id, data|
+          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
+        end
+      rescue
+      end
+    rescue
+      # Never raise from instrumentation install
+    end
+
+    def self.start_request_tracking
+      Thread.current[THREAD_LOCAL_KEY] = []
+    end
+
+    def self.stop_request_tracking
+      events = Thread.current[THREAD_LOCAL_KEY]
+      Thread.current[THREAD_LOCAL_KEY] = nil
+      events || []
+    end
+
+    def self.build_event(name, data, duration_ms)
+      return nil unless data.is_a?(Hash)
+
+      {
+        event: name,
+        duration_ms: duration_ms,
+        key: safe_key(data[:key]),
+        keys_count: safe_keys_count(data[:keys]),
+        hit: infer_hit(name, data),
+        store: safe_store_name(data[:store]),
+        namespace: safe_namespace(data[:namespace]),
+        at: Time.now.utc.to_i
+      }
+    rescue
+      nil
+    end
+
+    def self.safe_key(key)
+      return nil if key.nil?
+      s = key.to_s
+      (s.length > 200) ? s[0, 200] + "…" : s
+    rescue
+      nil
+    end
+
+    def self.safe_keys_count(keys)
+      if keys.respond_to?(:size)
+        keys.size
+      end
+    rescue
+      nil
+    end
+
+    def self.safe_store_name(store)
+      return nil unless store
+      if store.respond_to?(:name)
+        store.name
+      else
+        store.class.name
+      end
+    rescue
+      nil
+    end
+
+    def self.safe_namespace(ns)
+      ns.to_s[0, 100]
+    rescue
+      nil
+    end
+
+    def self.infer_hit(name, data)
+      case name
+      when "cache_fetch_hit.active_support"
+        true
+      when "cache_read.active_support"
+        !!data[:hit]
+      end
+    rescue
+      nil
+    end
+  end
+end

data/lib/dead_bro/circuit_breaker.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+module DeadBro
+  class CircuitBreaker
+    # Circuit breaker states
+    CLOSED = :closed
+    OPEN = :open
+    HALF_OPEN = :half_open
+
+    # Default configuration
+    DEFAULT_FAILURE_THRESHOLD = 3
+    DEFAULT_RECOVERY_TIMEOUT = 60 # seconds
+    DEFAULT_RETRY_TIMEOUT = 300 # seconds for retry attempts
+
+    def initialize(
+      failure_threshold: DEFAULT_FAILURE_THRESHOLD,
+      recovery_timeout: DEFAULT_RECOVERY_TIMEOUT,
+      retry_timeout: DEFAULT_RETRY_TIMEOUT
+    )
+      @failure_threshold = failure_threshold
+      @recovery_timeout = recovery_timeout
+      @retry_timeout = retry_timeout
+
+      @state = CLOSED
+      @failure_count = 0
+      @last_failure_time = nil
+      @last_success_time = nil
+    end
+
+    def call(&block)
+      case @state
+      when CLOSED
+        execute_with_monitoring(&block)
+      when OPEN
+        if should_attempt_reset?
+          @state = HALF_OPEN
+          execute_with_monitoring(&block)
+        else
+          :circuit_open
+        end
+      when HALF_OPEN
+        execute_with_monitoring(&block)
+      end
+    end
+
+    attr_reader :state
+
+    attr_reader :failure_count
+
+    attr_reader :last_failure_time
+
+    attr_reader :last_success_time
+
+    def reset!
+      @state = CLOSED
+      @failure_count = 0
+      @last_failure_time = nil
+    end
+
+    def open!
+      @state = OPEN
+      @last_failure_time = Time.now
+    end
+
+    def transition_to_half_open!
+      @state = HALF_OPEN
+    end
+
+    def should_attempt_reset?
+      return false unless @last_failure_time
+
+      # Try to reset after recovery timeout
+      elapsed = Time.now - @last_failure_time
+      elapsed >= @recovery_timeout
+    end
+
+    private
+
+    def execute_with_monitoring(&block)
+      result = block.call
+
+      if success?(result)
+        on_success
+        result
+      else
+        on_failure
+        result
+      end
+    rescue => e
+      on_failure
+      raise e
+    end
+
+    def success?(result)
+      # Consider 2xx status codes as success
+      result.is_a?(Net::HTTPSuccess)
+    end
+
+    def on_success
+      @failure_count = 0
+      @last_success_time = Time.now
+      @state = CLOSED
+    end
+
+    def on_failure
+      @failure_count += 1
+      @last_failure_time = Time.now
+
+      # If we're in half-open state and get a failure, go back to open
+      if @state == HALF_OPEN
+        @state = OPEN
+      elsif @failure_count >= @failure_threshold
+        @state = OPEN
+      end
+    end
+  end
+end

data/lib/dead_bro/client.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+require "net/http"
+require "uri"
+require "json"
+require "timeout"
+
+module DeadBro
+  class Client
+    def initialize(configuration = DeadBro.configuration)
+      @configuration = configuration
+      @circuit_breaker = create_circuit_breaker
+    end
+
+    def post_metric(event_name:, payload:)
+      return if @configuration.api_key.nil?
+      return unless @configuration.enabled
+
+      # 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
+
+      # Make the HTTP request (async)
+      make_http_request(event_name, payload, @configuration.api_key)
+
+      nil
+    end
+
+    private
+
+    def create_circuit_breaker
+      return nil unless @configuration.circuit_breaker_enabled
+
+      CircuitBreaker.new(
+        failure_threshold: @configuration.circuit_breaker_failure_threshold,
+        recovery_timeout: @configuration.circuit_breaker_recovery_timeout,
+        retry_timeout: @configuration.circuit_breaker_retry_timeout
+      )
+    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}"
+      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
+        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)
+      else
+        $stdout.puts(message)
+      end
+    end
+  end
+end

data/lib/dead_bro/configuration.rb

@@ -0,0 +1,146 @@
+# frozen_string_literal: true
+
+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
+
+    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
+      @sample_rate = 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
+    end
+
+    def resolve_deploy_id
+      ENV["dead_bro_DEPLOY_ID"] || ENV["GIT_REV"] || ENV["HEROKU_SLUG_COMMIT"] || DeadBro.process_deploy_id
+    end
+
+    def excluded_controller?(controller_name, action_name = nil)
+      return false if @excluded_controllers.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
+        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) }
+    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) }
+    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) }
+    end
+
+    def exclusive_controller?(controller_name, action_name)
+      return true if @exclusive_controllers.empty? # If not defined, allow all (default behavior)
+      target = "#{controller_name}##{action_name}"
+      @exclusive_controllers.any? { |pat| match_name_or_pattern?(target, pat) }
+    end
+
+
+    def should_sample?
+      sample_rate = resolve_sample_rate
+      return true if sample_rate >= 100
+      return false if sample_rate <= 0
+
+      # Generate random number 1-100 and check if it's within sample rate
+      rand(1..100) <= sample_rate
+    end
+    
+    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
+    end
+    
+    def resolve_api_key
+      return @api_key unless @api_key.nil?
+      
+      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)
+      return false if name.nil? || pattern.nil?
+      pat = pattern.to_s
+      return !!(name.to_s == pat) unless pat.include?("*")
+      
+      # For controller action patterns (containing '#'), use .* to match any characters including colons
+      # For controller-only patterns, use [^:]* to match namespace segments
+      if pat.include?("#")
+        # Controller action pattern: allow * to match any characters including colons
+        regex = Regexp.new("^" + Regexp.escape(pat).gsub("\\*", ".*") + "$")
+      else
+        # Controller-only pattern: use [^:]* to match namespace segments
+        regex = Regexp.new("^" + Regexp.escape(pat).gsub("\\*", "[^:]*") + "$")
+      end
+      !!(name.to_s =~ regex)
+    rescue
+      false
+    end
+
+  end
+end

data/lib/dead_bro/error_middleware.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+require "rack"
+
+module DeadBro
+  class ErrorMiddleware
+    EVENT_NAME = "exception.uncaught"
+
+    def initialize(app, client = nil)
+      @app = app
+      @client = client || DeadBro.client
+    end
+
+    def call(env)
+      @app.call(env)
+    rescue Exception => exception # rubocop:disable Lint/RescueException
+      begin
+        payload = build_payload(exception, env)
+        # 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)
+      rescue
+        # Never let APM reporting interfere with the host app
+      end
+      raise
+    end
+
+    private
+
+    def build_payload(exception, env)
+      req = rack_request(env)
+
+      {
+        exception_class: exception.class.name,
+        message: truncate(exception.message.to_s, 1000),
+        backtrace: safe_backtrace(exception),
+        occurred_at: Time.now.utc.to_i,
+        rack:
+          {
+            method: req&.request_method,
+            path: req&.path,
+            fullpath: req&.fullpath,
+            ip: req&.ip,
+            user_agent: truncate(req&.user_agent.to_s, 200),
+            params: safe_params(req),
+            request_id: env["action_dispatch.request_id"] || env["HTTP_X_REQUEST_ID"],
+            referer: truncate(env["HTTP_REFERER"].to_s, 500),
+            host: env["HTTP_HOST"]
+          },
+        rails_env: safe_rails_env,
+        app: safe_app_name,
+        pid: Process.pid,
+        logs: DeadBro.logger.logs
+      }
+    end
+
+    def rack_request(env)
+      ::Rack::Request.new(env)
+    rescue
+      nil
+    end
+
+    def safe_backtrace(exception)
+      Array(exception.backtrace).first(50)
+    rescue
+      []
+    end
+
+    def safe_params(req)
+      return {} unless req
+
+      params = req.params || {}
+      sensitive_keys = %w[password password_confirmation token secret key authorization api_key]
+      filtered = params.dup
+      sensitive_keys.each do |k|
+        filtered.delete(k)
+        filtered.delete(k.to_sym)
+      end
+      JSON.parse(JSON.dump(filtered)) # ensure JSON-safe
+    rescue
+      {}
+    end
+
+    def truncate(str, max)
+      return str if str.nil? || str.length <= max
+      str[0..(max - 1)]
+    end
+
+    def safe_rails_env
+      if defined?(Rails) && Rails.respond_to?(:env)
+        Rails.env
+      else
+        ENV["RAILS_ENV"] || ENV["RACK_ENV"] || "development"
+      end
+    rescue
+      "development"
+    end
+
+    def safe_app_name
+      if defined?(Rails) && Rails.respond_to?(:application)
+        begin
+          Rails.application.class.module_parent_name
+        rescue
+          ""
+        end
+      else
+        ""
+      end
+    end
+  end
+end

data/lib/dead_bro/http_instrumentation.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+require "uri"
+require "net/http"
+
+module DeadBro
+  module HttpInstrumentation
+    EVENT_NAME = "outgoing.http"
+
+    def self.install!(client: Client.new)
+      install_net_http!(client)
+      install_typhoeus!(client) if defined?(::Typhoeus)
+    rescue
+      # Never raise from instrumentation install
+    end
+
+    def self.install_net_http!(client)
+      mod = Module.new do
+        define_method(:request) do |req, body = nil, &block|
+          start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+          response = nil
+          error = nil
+          begin
+            response = super(req, body, &block)
+            response
+          rescue Exception => e
+            error = e
+            raise
+          ensure
+            finish_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+            duration_ms = ((finish_time - start_time) * 1000.0).round(2)
+            begin
+              uri = begin
+                URI.parse(req.uri ? req.uri.to_s : "http://#{@address}:#{@port}#{req.path}")
+              rescue
+                nil
+              end
+
+              # Skip instrumentation for our own APM endpoint to prevent infinite loops,
+              # but do NOT alter the original method's return value/control flow.
+              skip_instrumentation = uri && (uri.to_s.include?("localhost") || uri.to_s.include?("aberatii.com"))
+
+              unless skip_instrumentation
+                payload = {
+                  library: "net_http",
+                  method: req.method,
+                  url: uri && uri.to_s,
+                  host: (uri && uri.host) || @address,
+                  path: (uri && uri.path) || req.path,
+                  status: response && response.code.to_i,
+                  duration_ms: duration_ms,
+                  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
+                end
+              end
+            rescue
+            end
+          end
+        end
+      end
+
+      ::Net::HTTP.prepend(mod) unless ::Net::HTTP.ancestors.include?(mod)
+    end
+
+    def self.install_typhoeus!(client)
+      mod = Module.new do
+        define_method(:run) do |*args|
+          start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+          response = nil
+          begin
+            response = super(*args)
+            response
+          ensure
+            finish_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+            duration_ms = ((finish_time - start_time) * 1000.0).round(2)
+            begin
+              req_url = if respond_to?(:url)
+                url
+              else
+                (respond_to?(:base_url) ? base_url : nil)
+              end
+
+              # Skip instrumentation for our own APM endpoint to prevent infinite loops,
+              # but do NOT alter the original method's return value/control flow.
+              skip_instrumentation = req_url && (req_url.include?("localhost:3100/apm/v1/metrics") || req_url.include?("deadbro.aberatii.com/apm/v1/metrics"))
+
+              unless skip_instrumentation
+                payload = {
+                  library: "typhoeus",
+                  method: (respond_to?(:options) && options[:method]) ? options[:method].to_s.upcase : nil,
+                  url: req_url,
+                  status: response && response.code,
+                  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
+                end
+              end
+            rescue
+            end
+          end
+        end
+      end
+
+      ::Typhoeus::Request.prepend(mod) unless ::Typhoeus::Request.ancestors.include?(mod)
+    rescue
+    end
+  end
+end