dead_bro 0.2.2 → 0.2.3

data/lib/dead_bro/collectors/process_info.rb

@@ -0,0 +1,178 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "rbconfig"
+require "socket"
+
+module DeadBro
+  module Collectors
+    # ProcessInfo collector exposes Ruby / Rails / process level metrics such as
+    # RSS, thread count, file descriptor count, GC stats and uptime.
+    #
+    # All methods are best-effort and will return nil on failure rather than
+    # raising exceptions.
+    module ProcessInfo
+      module_function
+
+      def collect
+        now = Time.now.utc
+
+        {
+          pid: Process.pid,
+          hostname: safe_hostname,
+          boot_time: rails_boot_time,
+          uptime_s: uptime_seconds(now),
+          ruby_version: RUBY_VERSION,
+          rails_version: safe_rails_version,
+          app_env: DeadBro.env,
+          rss_bytes: rss_bytes,
+          thread_count: thread_count,
+          fd_count: fd_count,
+          gc: gc_stats
+        }
+      rescue => e
+        {
+          error_class: e.class.name,
+          error_message: e.message.to_s[0, 500]
+        }
+      end
+
+      def linux?
+        host_os = RbConfig::CONFIG["host_os"].to_s.downcase
+        host_os.include?("linux")
+      rescue
+        false
+      end
+
+      def macos?
+        host_os = RbConfig::CONFIG["host_os"].to_s.downcase
+        host_os.include?("darwin")
+      rescue
+        false
+      end
+
+      def safe_hostname
+        Socket.gethostname
+      rescue
+        "unknown"
+      end
+
+      def rails_boot_time
+        return nil unless defined?(Rails)
+
+        if Rails.respond_to?(:application) && Rails.application.respond_to?(:config)
+          # Rails does not expose boot time directly; approximate with process start
+          process_start_time
+        else
+          process_start_time
+        end
+      rescue
+        nil
+      end
+
+      def process_start_time
+        @process_start_time ||= Time.now.utc
+      end
+
+      def uptime_seconds(now = Time.now.utc)
+        (now.to_f - process_start_time.to_f).round(2)
+      rescue
+        nil
+      end
+
+      def safe_rails_version
+        if defined?(Rails) && Rails.respond_to?(:version)
+          Rails.version
+        elsif defined?(Rails::VERSION) && Rails::VERSION::STRING
+          Rails::VERSION::STRING
+        end
+      rescue
+        nil
+      end
+
+      def rss_bytes
+        if linux? && File.readable?("/proc/self/status")
+          parse_proc_status_for_rss("/proc/self/status")
+        else
+          rss_from_ps
+        end
+      rescue
+        nil
+      end
+
+      def parse_proc_status_for_rss(path)
+        File.foreach(path) do |line|
+          next unless line.start_with?("VmRSS:")
+
+          parts = line.split
+          value_kb = begin
+            Integer(parts[1])
+          rescue
+            nil
+          end
+          return value_kb * 1024 if value_kb
+        end
+        nil
+      rescue
+        nil
+      end
+
+      def rss_from_ps
+        rss_kb = `ps -o rss= -p #{Process.pid}`.to_i
+        return nil if rss_kb <= 0
+
+        rss_kb * 1024
+      rescue
+        nil
+      end
+
+      def thread_count
+        if linux? && File.readable?("/proc/self/status")
+          File.foreach("/proc/self/status") do |line|
+            next unless line.start_with?("Threads:")
+
+            parts = line.split
+            begin
+              return Integer(parts[1])
+            rescue
+              nil
+            end
+          end
+          nil
+        else
+          Thread.list.size
+        end
+      rescue
+        nil
+      end
+
+      def fd_count
+        if linux? && File.directory?("/proc/self/fd")
+          Dir.entries("/proc/self/fd").size - 2 # exclude . and ..
+        elsif macos? && File.directory?("/dev/fd")
+          Dir.entries("/dev/fd").size - 2
+        else
+          # Best-effort: count file descriptors under /proc when available
+          nil
+        end
+      rescue
+        nil
+      end
+
+      def gc_stats
+        return {} unless defined?(GC) && GC.respond_to?(:stat)
+
+        stats = GC.stat
+        {
+          heap_live_slots: stats[:heap_live_slots],
+          heap_free_slots: stats[:heap_free_slots],
+          total_allocated_objects: stats[:total_allocated_objects],
+          major_gc_count: stats[:major_gc_count],
+          minor_gc_count: stats[:minor_gc_count]
+        }
+      rescue
+        {}
+      end
+    end
+  end
+end

data/lib/dead_bro/collectors/sample_store.rb

@@ -0,0 +1,108 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "json"
+require "digest"
+
+module DeadBro
+  module Collectors
+    # SampleStore provides a tiny, best-effort persistence layer for
+    # time-series samples (CPU, network, etc.) between runs.
+    #
+    # It prefers Redis via Sidekiq when available and otherwise falls back
+    # to a JSON file in /tmp. All failures are swallowed and simply result
+    # in nil being returned from #load.
+    module SampleStore
+      module_function
+
+      def load(key)
+        load_from_redis(key) || load_from_file(key)
+      rescue
+        nil
+      end
+
+      def save(key, data)
+        save_to_redis(key, data)
+      rescue
+        # If Redis is unavailable or fails, fall back to file-based storage
+      ensure
+        begin
+          save_to_file(key, data)
+        rescue
+          # Completely best-effort
+        end
+      end
+
+      def load_from_redis(key)
+        return nil unless defined?(Sidekiq) && Sidekiq.respond_to?(:redis)
+
+        raw = Sidekiq.redis { |r| r.get(redis_key(key)) }
+        return nil unless raw
+
+        JSON.parse(raw)
+      rescue
+        nil
+      end
+
+      def save_to_redis(key, data)
+        return unless defined?(Sidekiq) && Sidekiq.respond_to?(:redis)
+
+        Sidekiq.redis do |r|
+          r.set(redis_key(key), JSON.dump(data), ex: 300) # keep for 5 minutes
+        end
+      rescue
+        # Best-effort only
+      end
+
+      def load_from_file(key)
+        path = file_path(key)
+        return nil unless File.file?(path)
+
+        File.open(path, "r") do |f|
+          JSON.parse(f.read)
+        end
+      rescue
+        nil
+      end
+
+      def save_to_file(key, data)
+        path = file_path(key)
+        dir = File.dirname(path)
+        Dir.mkdir(dir) unless Dir.exist?(dir)
+
+        File.open(path, File::RDWR | File::CREAT, 0o600) do |f|
+          f.flock(File::LOCK_EX)
+          f.rewind
+          f.truncate(0)
+          f.write(JSON.dump(data))
+        ensure
+          begin
+            f.flock(File::LOCK_UN)
+          rescue
+          end
+        end
+      rescue
+        # Best-effort only
+      end
+
+      def redis_key(key)
+        env = DeadBro.env
+        host = begin
+          require "socket"
+          Socket.gethostname
+        rescue
+          "unknown"
+        end
+
+        "dead_bro:metrics:#{env}:#{host}:#{key}"
+      end
+
+      def file_path(key)
+        digest = Digest::SHA256.hexdigest(key.to_s)[0, 16]
+        File.join(Dir.tmpdir, "dead_bro_metrics_#{digest}.json")
+      rescue
+        "/tmp/dead_bro_metrics_#{key.to_s.gsub(/[^a-zA-Z0-9]/, "_")}.json"
+      end
+    end
+  end
+end

data/lib/dead_bro/collectors/system.rb

@@ -0,0 +1,206 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "rbconfig"
+
+module DeadBro
+  module Collectors
+    # System collector provides best-effort CPU and memory statistics
+    # using cgroups when available and falling back to /proc on Linux.
+    #
+    # CPU percentages are normalised to 0..100 across all cores. The first
+    # run may not contain a CPU percentage because there is no previous
+    # sample to diff against.
+    module System
+      module_function
+
+      CPU_SAMPLE_KEY = "cpu"
+      MEMINFO_PATH = "/proc/meminfo"
+
+      def collect
+        return {enabled: false} unless system_enabled?
+
+        {
+          cpu_pct: cpu_percentage,
+          mem_used_bytes: mem_used_bytes,
+          mem_total_bytes: mem_total_bytes,
+          mem_available_bytes: mem_available_bytes,
+          disk: Filesystem.collect
+        }
+      rescue => e
+        {
+          error_class: e.class.name,
+          error_message: e.message.to_s[0, 500]
+        }
+      end
+
+      def system_enabled?
+        DeadBro.configuration.respond_to?(:enable_system_stats) &&
+          DeadBro.configuration.enable_system_stats
+      rescue
+        false
+      end
+
+      def linux?
+        host_os = RbConfig::CONFIG["host_os"].to_s.downcase
+        host_os.include?("linux")
+      rescue
+        false
+      end
+
+      def macos?
+        host_os = RbConfig::CONFIG["host_os"].to_s.downcase
+        host_os.include?("darwin")
+      rescue
+        false
+      end
+
+      # CPU percentage normalised to 0..100
+      def cpu_percentage
+        if linux?
+          cpu_percentage_linux
+        elsif macos?
+          cpu_percentage_macos
+        end
+      end
+
+      def cpu_percentage_linux
+        return nil unless File.readable?("/proc/stat")
+
+        now = current_time
+        current = read_proc_stat
+        prev = SampleStore.load(CPU_SAMPLE_KEY)
+        SampleStore.save(CPU_SAMPLE_KEY, {"timestamp" => now, "stat" => current})
+
+        return nil unless prev && prev["stat"].is_a?(Hash) && prev["timestamp"]
+
+        cpu_pct_from_samples(prev["stat"], current)
+      rescue
+        nil
+      end
+
+      def cpu_percentage_macos
+        output = `top -l 1 -n 0 | grep "CPU usage"`
+        # Example: CPU usage: 9.38% user, 10.93% sys, 79.68% idle
+        if output =~ /([\d.]+)% idle/
+          idle = $1.to_f
+          (100.0 - idle).round(2)
+        end
+      rescue
+        nil
+      end
+
+      def current_time
+        Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      rescue
+        Time.now.to_f
+      end
+
+      # Parse the first "cpu" line from /proc/stat
+      def read_proc_stat
+        File.foreach("/proc/stat") do |line|
+          next unless line.start_with?("cpu ")
+
+          fields = line.split
+          # cpu  user nice system idle iowait irq softirq steal guest guest_nice
+          values = fields[1..-1].map { |v| v.to_i }
+          total = values.sum
+          idle = values[3] + values[4] # idle + iowait
+          return {"total" => total, "idle" => idle}
+        end
+        {}
+      rescue
+        {}
+      end
+
+      # Computes a CPU percentage from two /proc/stat samples.
+      # This is intentionally public so it can be unit tested.
+      def cpu_pct_from_samples(prev, current)
+        prev_total = prev["total"].to_f
+        prev_idle = prev["idle"].to_f
+        cur_total = current["total"].to_f
+        cur_idle = current["idle"].to_f
+
+        total_delta = cur_total - prev_total
+        idle_delta = cur_idle - prev_idle
+        return nil if total_delta <= 0
+
+        usage = (total_delta - idle_delta) / total_delta.to_f
+        pct = (usage * 100.0)
+        return nil unless pct.finite?
+
+        pct.round(2)
+      rescue
+        nil
+      end
+
+      def meminfo
+        return {} unless linux? && File.readable?(MEMINFO_PATH)
+
+        info = {}
+        File.foreach(MEMINFO_PATH) do |line|
+          key, value, _ = line.split
+          next unless key && value
+
+          key = key.sub(":", "")
+          info[key] = begin
+            Integer(value)
+          rescue
+            nil
+          end
+        end
+        info
+      rescue
+        {}
+      end
+
+      def mem_total_bytes
+        if linux?
+          info = meminfo
+          total_kb = info["MemTotal"]
+          return nil unless total_kb
+          total_kb * 1024
+        elsif macos?
+          `sysctl -n hw.memsize`.to_i
+        end
+      rescue
+        nil
+      end
+
+      def mem_available_bytes
+        if linux?
+          info = meminfo
+          avail_kb = info["MemAvailable"] || info["MemFree"]
+          return nil unless avail_kb
+          avail_kb * 1024
+        elsif macos?
+          # vm_stat output:
+          # Pages free:                               3632.
+          # Pages active:                           138466.
+          # Pages inactive:                         134812.
+          # ...
+          output = `vm_stat`
+          pages_free = output[/Pages free:\s+(\d+)/, 1].to_i
+          pages_inactive = output[/Pages inactive:\s+(\d+)/, 1].to_i
+
+          # MacOS page size is typically 4096 bytes
+          (pages_free + pages_inactive) * 4096
+        else
+          nil
+        end
+      rescue
+        nil
+      end
+
+      def mem_used_bytes
+        total = mem_total_bytes
+        avail = mem_available_bytes
+        return nil unless total && avail
+
+        total - avail
+      rescue
+        nil
+      end
+    end
+  end
+end

data/lib/dead_bro/collectors.rb

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+module DeadBro
+  module Collectors
+    autoload :Jobs, "dead_bro/collectors/jobs"
+    autoload :Database, "dead_bro/collectors/database"
+    autoload :ProcessInfo, "dead_bro/collectors/process_info"
+    autoload :System, "dead_bro/collectors/system"
+    autoload :Filesystem, "dead_bro/collectors/filesystem"
+    autoload :Network, "dead_bro/collectors/network"
+    autoload :SampleStore, "dead_bro/collectors/sample_store"
+  end
+end

data/lib/dead_bro/configuration.rb

@@ -2,11 +2,12 @@
 
 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,
-    :job_queue_monitoring_enabled
+    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,
+      :job_queue_monitoring_enabled, :enable_db_stats, :enable_process_stats, :enable_system_stats,
+      :disk_paths, :interfaces_ignore
 
     def initialize
       @api_key = nil
@@ -30,6 +31,11 @@ module DeadBro
       @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
+      @enable_db_stats = false
+      @enable_process_stats = false
+      @enable_system_stats = false
+      @disk_paths = ["/"]
+      @interfaces_ignore = %w[lo lo0 docker0]
     end
 
     def resolve_deploy_id
@@ -38,7 +44,7 @@ module DeadBro
 
     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}"
@@ -55,7 +61,7 @@ module DeadBro
         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?
@@ -78,7 +84,6 @@ module DeadBro
       @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
@@ -87,10 +92,10 @@ module DeadBro
       # 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
@@ -105,10 +110,10 @@ module DeadBro
         100 # default
       end
     end
-    
+
     def resolve_api_key
       return @api_key unless @api_key.nil?
-      
+
       ENV["DEAD_BRO_API_KEY"]
     end
 
@@ -129,20 +134,19 @@ module DeadBro
       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?("#")
+      regex = if pat.include?("#")
         # Controller action pattern: allow * to match any characters including colons
-        regex = Regexp.new("^" + Regexp.escape(pat).gsub("\\*", ".*") + "$")
+        Regexp.new("^" + Regexp.escape(pat).gsub("\\*", ".*") + "$")
       else
         # Controller-only pattern: use [^:]* to match namespace segments
-        regex = Regexp.new("^" + Regexp.escape(pat).gsub("\\*", "[^:]*") + "$")
+        Regexp.new("^" + Regexp.escape(pat).gsub("\\*", "[^:]*") + "$")
       end
       !!(name.to_s =~ regex)
     rescue
       false
     end
-
   end
 end

data/lib/dead_bro/error_middleware.rb

@@ -48,7 +48,7 @@ module DeadBro
             referer: truncate(env["HTTP_REFERER"].to_s, 500),
             host: env["HTTP_HOST"]
           },
-        rails_env: safe_rails_env,
+        rails_env: DeadBro.env,
         app: safe_app_name,
         pid: Process.pid,
         logs: DeadBro.logger.logs
@@ -87,16 +87,6 @@ module DeadBro
       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

data/lib/dead_bro/http_instrumentation.rb

@@ -116,17 +116,17 @@ module DeadBro
     def self.should_continue_tracking?
       events = Thread.current[THREAD_LOCAL_KEY]
       return false unless events
-      
+
       # Check count limit
       return false if events.length >= MAX_TRACKED_EVENTS
-      
+
       # Check time limit
       start_time = Thread.current[DeadBro::TRACKING_START_TIME_KEY]
       if start_time
         elapsed_seconds = Time.now - start_time
         return false if elapsed_seconds >= DeadBro::MAX_TRACKING_DURATION_SECONDS
       end
-      
+
       true
     end
   end

data/lib/dead_bro/job_sql_tracking_middleware.rb

@@ -7,10 +7,10 @@ module DeadBro
       ActiveSupport::Notifications.subscribe("perform_start.active_job") do |name, started, finished, _unique_id, data|
         # Clear logs for this job
         DeadBro.logger.clear
-        
+
         # Set tracking start time once for all subscribers (before starting any tracking)
         Thread.current[DeadBro::TRACKING_START_TIME_KEY] = Time.now
-        
+
         DeadBro::SqlSubscriber.start_request_tracking
 
         # Start lightweight memory tracking for this job

data/lib/dead_bro/job_subscriber.rb

@@ -75,7 +75,7 @@ module DeadBro
           duration_ms: duration_ms,
           status: "completed",
           sql_queries: sql_queries,
-          rails_env: safe_rails_env,
+          rails_env: DeadBro.env,
           host: safe_host,
           memory_usage: memory_usage_mb,
           gc_stats: gc_stats,
@@ -154,7 +154,7 @@ module DeadBro
           exception_class: exception&.class&.name,
           message: exception&.message&.to_s&.[](0, 1000),
           backtrace: Array(exception&.backtrace).first(50),
-          rails_env: safe_rails_env,
+          rails_env: DeadBro.env,
           host: safe_host,
           memory_usage: memory_usage_mb,
           gc_stats: gc_stats,
@@ -202,16 +202,6 @@ module DeadBro
       []
     end
 
-    def self.safe_rails_env
-      if defined?(Rails) && Rails.respond_to?(:env)
-        Rails.env
-      else
-        ENV["RACK_ENV"] || ENV["RAILS_ENV"] || "development"
-      end
-    rescue
-      "development"
-    end
-
     def self.safe_host
       if defined?(Rails) && Rails.respond_to?(:application)
         begin