dead_bro 0.2.0

data/lib/dead_bro/job_sql_tracking_middleware.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module DeadBro
+  class JobSqlTrackingMiddleware
+    def self.subscribe!
+      # Start SQL tracking when a job begins - use the start event, not the complete event
+      ActiveSupport::Notifications.subscribe("perform_start.active_job") do |name, started, finished, _unique_id, data|
+        # Clear logs for this job
+        DeadBro.logger.clear
+        DeadBro::SqlSubscriber.start_request_tracking
+
+        # Start lightweight memory tracking for this job
+        if defined?(DeadBro::LightweightMemoryTracker)
+          DeadBro::LightweightMemoryTracker.start_request_tracking
+        end
+
+        # Start detailed memory tracking when allocation tracking is enabled
+        if DeadBro.configuration.allocation_tracking_enabled && defined?(DeadBro::MemoryTrackingSubscriber)
+          DeadBro::MemoryTrackingSubscriber.start_request_tracking
+        end
+      end
+    rescue
+      # Never raise from instrumentation install
+    end
+  end
+end

data/lib/dead_bro/job_subscriber.rb

@@ -0,0 +1,243 @@
+# frozen_string_literal: true
+
+begin
+  require "active_support/notifications"
+rescue LoadError
+  # ActiveSupport not available
+end
+
+module DeadBro
+  class JobSubscriber
+    JOB_EVENT_NAME = "perform.active_job"
+    JOB_EXCEPTION_EVENT_NAME = "exception.active_job"
+
+    def self.subscribe!(client: Client.new)
+      # Track job execution
+      ActiveSupport::Notifications.subscribe(JOB_EVENT_NAME) do |name, started, finished, _unique_id, data|
+        begin
+          job_class_name = data[:job].class.name
+          if DeadBro.configuration.excluded_job?(job_class_name)
+            next
+          end
+          # If exclusive_jobs is defined and not empty, only track matching jobs
+          unless DeadBro.configuration.exclusive_job?(job_class_name)
+            next
+          end
+        rescue
+        end
+
+        duration_ms = ((finished - started) * 1000.0).round(2)
+
+        # Get SQL queries executed during this job
+        sql_queries = DeadBro::SqlSubscriber.stop_request_tracking
+
+        # Stop memory tracking and get collected memory data
+        if DeadBro.configuration.allocation_tracking_enabled && defined?(DeadBro::MemoryTrackingSubscriber)
+          detailed_memory = DeadBro::MemoryTrackingSubscriber.stop_request_tracking
+          memory_performance = DeadBro::MemoryTrackingSubscriber.analyze_memory_performance(detailed_memory)
+          # Keep memory_events compact and user-friendly (no large raw arrays)
+          memory_events = {
+            memory_before: detailed_memory[:memory_before],
+            memory_after: detailed_memory[:memory_after],
+            duration_seconds: detailed_memory[:duration_seconds],
+            allocations_count: (detailed_memory[:allocations] || []).length,
+            memory_snapshots_count: (detailed_memory[:memory_snapshots] || []).length,
+            large_objects_count: (detailed_memory[:large_objects] || []).length
+          }
+        else
+          lightweight_memory = DeadBro::LightweightMemoryTracker.stop_request_tracking
+          # Separate raw readings from derived performance metrics to avoid duplicating data
+          memory_events = {
+            memory_before: lightweight_memory[:memory_before],
+            memory_after: lightweight_memory[:memory_after]
+          }
+          memory_performance = {
+            memory_growth_mb: lightweight_memory[:memory_growth_mb],
+            gc_count_increase: lightweight_memory[:gc_count_increase],
+            heap_pages_increase: lightweight_memory[:heap_pages_increase],
+            duration_seconds: lightweight_memory[:duration_seconds]
+          }
+        end
+
+        payload = {
+          job_class: data[:job].class.name,
+          job_id: data[:job].job_id,
+          queue_name: data[:job].queue_name,
+          arguments: safe_arguments(data[:job].arguments),
+          duration_ms: duration_ms,
+          status: "completed",
+          sql_queries: sql_queries,
+          rails_env: safe_rails_env,
+          host: safe_host,
+          memory_usage: memory_usage_mb,
+          gc_stats: gc_stats,
+          memory_events: memory_events,
+          memory_performance: memory_performance,
+          logs: DeadBro.logger.logs
+        }
+
+        client.post_metric(event_name: name, payload: payload)
+      end
+
+      # Track job exceptions
+      ActiveSupport::Notifications.subscribe(JOB_EXCEPTION_EVENT_NAME) do |name, started, finished, _unique_id, data|
+        begin
+          job_class_name = data[:job].class.name
+          if DeadBro.configuration.excluded_job?(job_class_name)
+            next
+          end
+          # If exclusive_jobs is defined and not empty, only track matching jobs
+          unless DeadBro.configuration.exclusive_job?(job_class_name)
+            next
+          end
+        rescue
+        end
+
+        duration_ms = ((finished - started) * 1000.0).round(2)
+        exception = data[:exception_object]
+
+        # Get SQL queries executed during this job
+        sql_queries = DeadBro::SqlSubscriber.stop_request_tracking
+
+        # Stop memory tracking and get collected memory data
+        if DeadBro.configuration.allocation_tracking_enabled && defined?(DeadBro::MemoryTrackingSubscriber)
+          detailed_memory = DeadBro::MemoryTrackingSubscriber.stop_request_tracking
+          memory_performance = DeadBro::MemoryTrackingSubscriber.analyze_memory_performance(detailed_memory)
+          # Keep memory_events compact and user-friendly (no large raw arrays)
+          memory_events = {
+            memory_before: detailed_memory[:memory_before],
+            memory_after: detailed_memory[:memory_after],
+            duration_seconds: detailed_memory[:duration_seconds],
+            allocations_count: (detailed_memory[:allocations] || []).length,
+            memory_snapshots_count: (detailed_memory[:memory_snapshots] || []).length,
+            large_objects_count: (detailed_memory[:large_objects] || []).length
+          }
+        else
+          lightweight_memory = DeadBro::LightweightMemoryTracker.stop_request_tracking
+          # Separate raw readings from derived performance metrics to avoid duplicating data
+          memory_events = {
+            memory_before: lightweight_memory[:memory_before],
+            memory_after: lightweight_memory[:memory_after]
+          }
+          memory_performance = {
+            memory_growth_mb: lightweight_memory[:memory_growth_mb],
+            gc_count_increase: lightweight_memory[:gc_count_increase],
+            heap_pages_increase: lightweight_memory[:heap_pages_increase],
+            duration_seconds: lightweight_memory[:duration_seconds]
+          }
+        end
+
+        payload = {
+          job_class: data[:job].class.name,
+          job_id: data[:job].job_id,
+          queue_name: data[:job].queue_name,
+          arguments: safe_arguments(data[:job].arguments),
+          duration_ms: duration_ms,
+          status: "failed",
+          sql_queries: sql_queries,
+          exception_class: exception&.class&.name,
+          message: exception&.message&.to_s&.[](0, 1000),
+          backtrace: Array(exception&.backtrace).first(50),
+          rails_env: safe_rails_env,
+          host: safe_host,
+          memory_usage: memory_usage_mb,
+          gc_stats: gc_stats,
+          memory_events: memory_events,
+          memory_performance: memory_performance,
+          logs: DeadBro.logger.logs
+        }
+
+        event_name = exception&.class&.name || "ActiveJob::Exception"
+        client.post_metric(event_name: event_name, payload: payload, error: true)
+      end
+    rescue
+      # Never raise from instrumentation install
+    end
+
+    private
+
+    def self.safe_arguments(arguments)
+      return [] unless arguments.is_a?(Array)
+
+      # Limit and sanitize job arguments
+      arguments.first(10).map do |arg|
+        case arg
+        when String
+          (arg.length > 200) ? arg[0, 200] + "..." : arg
+        when Hash
+          # Filter sensitive keys and limit size
+          filtered = arg.except(*%w[password token secret key])
+          (filtered.keys.size > 20) ? filtered.first(20).to_h : filtered
+        when Array
+          arg.first(5)
+        when ActiveRecord::Base
+          # Handle ActiveRecord objects safely
+          "#{arg.class.name}##{begin
+            arg.id
+          rescue
+            "unknown"
+          end}"
+        else
+          # Convert to string and truncate, but avoid object inspection
+          (arg.to_s.length > 200) ? arg.to_s[0, 200] + "..." : arg.to_s
+        end
+      end
+    rescue
+      []
+    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
+          Rails.application.class.module_parent_name
+        rescue
+          ""
+        end
+      else
+        ""
+      end
+    end
+
+    def self.memory_usage_mb
+      if defined?(GC) && GC.respond_to?(:stat)
+        # Get memory usage in MB
+        memory_kb = begin
+          `ps -o rss= -p #{Process.pid}`.to_i
+        rescue
+          0
+        end
+        (memory_kb / 1024.0).round(2)
+      else
+        0
+      end
+    rescue
+      0
+    end
+
+    def self.gc_stats
+      if defined?(GC) && GC.respond_to?(:stat)
+        stats = GC.stat
+        {
+          count: stats[:count] || 0,
+          heap_allocated_pages: stats[:heap_allocated_pages] || 0,
+          heap_sorted_pages: stats[:heap_sorted_pages] || 0,
+          total_allocated_objects: stats[:total_allocated_objects] || 0
+        }
+      else
+        {}
+      end
+    rescue
+      {}
+    end
+  end
+end

data/lib/dead_bro/lightweight_memory_tracker.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module DeadBro
+  class LightweightMemoryTracker
+    # Ultra-lightweight memory tracking with minimal performance impact
+    THREAD_LOCAL_KEY = :dead_bro_lightweight_memory
+
+    def self.start_request_tracking
+      return unless DeadBro.configuration.memory_tracking_enabled
+
+      # Only track essential metrics to minimize overhead
+      Thread.current[THREAD_LOCAL_KEY] = {
+        gc_before: lightweight_gc_stats,
+        memory_before: lightweight_memory_usage,
+        start_time: Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      }
+    end
+
+    def self.stop_request_tracking
+      events = Thread.current[THREAD_LOCAL_KEY]
+      Thread.current[THREAD_LOCAL_KEY] = nil
+
+      return {} unless events
+
+      # Calculate only essential metrics
+      gc_after = lightweight_gc_stats
+      memory_after = lightweight_memory_usage
+
+      {
+        memory_growth_mb: (memory_after - events[:memory_before]).round(2),
+        gc_count_increase: (gc_after[:count] || 0) - (events[:gc_before][:count] || 0),
+        heap_pages_increase: (gc_after[:heap_allocated_pages] || 0) - (events[:gc_before][:heap_allocated_pages] || 0),
+        duration_seconds: Process.clock_gettime(Process::CLOCK_MONOTONIC) - events[:start_time],
+        memory_before: events[:memory_before],
+        memory_after: memory_after
+      }
+    end
+
+    def self.lightweight_memory_usage
+      # Use only GC stats for memory estimation (no system calls)
+      return 0 unless defined?(GC) && GC.respond_to?(:stat)
+
+      gc_stats = GC.stat
+      heap_pages = gc_stats[:heap_allocated_pages] || 0
+      # Rough estimation: 4KB per page
+      (heap_pages * 4) / 1024.0 # Convert to MB
+    rescue
+      0
+    end
+
+    def self.lightweight_gc_stats
+      return {} unless defined?(GC) && GC.respond_to?(:stat)
+
+      stats = GC.stat
+      {
+        count: stats[:count] || 0,
+        heap_allocated_pages: stats[:heap_allocated_pages] || 0
+      }
+    rescue
+      {}
+    end
+  end
+end

data/lib/dead_bro/logger.rb

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+module DeadBro
+  class Logger
+    SEVERITY_LEVELS = {
+      debug: 0,
+      info: 1,
+      warn: 2,
+      error: 3,
+      fatal: 4
+    }.freeze
+
+    # ANSI color codes
+    COLOR_RESET = "\033[0m"
+    COLOR_DEBUG = "\033[36m"  # Cyan
+    COLOR_INFO = "\033[32m"   # Green
+    COLOR_WARN = "\033[33m"   # Yellow
+    COLOR_ERROR = "\033[31m" # Red
+    COLOR_FATAL = "\033[35m"  # Magenta
+
+    def initialize
+      @thread_logs_key = :dead_bro_logs
+    end
+
+    def debug(message)
+      log(:debug, message)
+    end
+
+    def info(message)
+      log(:info, message)
+    end
+
+    def warn(message)
+      log(:warn, message)
+    end
+
+    def error(message)
+      log(:error, message)
+    end
+
+    def fatal(message)
+      log(:fatal, message)
+    end
+
+    # Get all logs for the current thread
+    def logs
+      Thread.current[@thread_logs_key] || []
+    end
+
+    # Clear logs for the current thread
+    def clear
+      Thread.current[@thread_logs_key] = []
+    end
+
+    private
+
+    def log(severity, message)
+      timestamp = Time.now.utc
+      log_entry = {
+        sev: severity.to_s,
+        msg: message.to_s,
+        time: timestamp.iso8601(3) # Include milliseconds for better precision
+      }
+
+      # Store in thread-local storage
+      Thread.current[@thread_logs_key] ||= []
+      Thread.current[@thread_logs_key] << log_entry
+
+      # Print the message immediately
+      print_log(severity, message, timestamp)
+    end
+
+    def print_log(severity, message, timestamp)
+      formatted_message = format_log_message(severity, message, timestamp)
+
+      if defined?(Rails) && Rails.respond_to?(:logger) && Rails.logger
+        # Use Rails logger if available (Rails handles its own color formatting)
+        case severity
+        when :debug
+          Rails.logger.debug(formatted_message)
+        when :info
+          Rails.logger.info(formatted_message)
+        when :warn
+          Rails.logger.warn(formatted_message)
+        when :error
+          Rails.logger.error(formatted_message)
+        when :fatal
+          Rails.logger.fatal(formatted_message)
+        end
+      else
+        # Fallback to stdout with colors
+        colored_message = format_log_message_with_color(severity, message, timestamp)
+        $stdout.puts(colored_message)
+      end
+    rescue
+      # Never let logging break the application
+      $stdout.puts("[DeadBro] #{severity.to_s.upcase}: #{message}")
+    end
+
+    def format_log_message(severity, message, timestamp)
+      "[DeadBro] #{timestamp.iso8601(3)} #{severity.to_s.upcase}: #{message}"
+    end
+
+    def format_log_message_with_color(severity, message, timestamp)
+      color = color_for_severity(severity)
+      severity_str = severity.to_s.upcase
+      "#{color}[DeadBro] #{timestamp.iso8601(3)} #{severity_str}: #{message}#{COLOR_RESET}"
+    end
+
+    def color_for_severity(severity)
+      case severity
+      when :debug
+        COLOR_DEBUG
+      when :info
+        COLOR_INFO
+      when :warn
+        COLOR_WARN
+      when :error
+        COLOR_ERROR
+      when :fatal
+        COLOR_FATAL
+      else
+        COLOR_RESET
+      end
+    end
+  end
+end

data/lib/dead_bro/memory_helpers.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+module DeadBro
+  module MemoryHelpers
+    # Helper methods for memory tracking and leak detection
+
+    # Take a memory snapshot with a custom label
+    def self.snapshot(label)
+      DeadBro::MemoryTrackingSubscriber.take_memory_snapshot(label)
+    end
+
+    # Get current memory analysis
+    def self.analyze_memory
+      DeadBro::MemoryLeakDetector.get_memory_analysis
+    end
+
+    # Check for memory leaks
+    def self.check_for_leaks
+      analysis = analyze_memory
+      if analysis[:leak_alerts]&.any?
+        puts "🚨 Memory leak detected!"
+        analysis[:leak_alerts].each do |alert|
+          puts "  - Growth: #{alert[:memory_growth_mb]}MB"
+          puts "  - Rate: #{alert[:growth_rate_mb_per_second]}MB/sec"
+          puts "  - Confidence: #{(alert[:confidence] * 100).round(1)}%"
+          puts "  - Recent controllers: #{alert[:recent_controllers].join(", ")}"
+        end
+      else
+        puts "✅ No memory leaks detected"
+      end
+      analysis
+    end
+
+    # Get memory usage summary
+    def self.memory_summary
+      analysis = analyze_memory
+      return "Insufficient data" if analysis[:status] == "insufficient_data"
+
+      memory_stats = analysis[:memory_stats]
+      puts "📊 Memory Summary:"
+      puts "  - Current: #{memory_stats[:mean]}MB (avg)"
+      puts "  - Range: #{memory_stats[:min]}MB - #{memory_stats[:max]}MB"
+      puts "  - Volatility: #{memory_stats[:std_dev]}MB"
+      puts "  - Samples: #{analysis[:sample_count]}"
+
+      if analysis[:memory_trend][:slope] > 0
+        puts "  - Trend: ↗️ Growing at #{analysis[:memory_trend][:slope].round(3)}MB/sec"
+      elsif analysis[:memory_trend][:slope] < 0
+        puts "  - Trend: ↘️ Shrinking at #{analysis[:memory_trend][:slope].abs.round(3)}MB/sec"
+      else
+        puts "  - Trend: ➡️ Stable"
+      end
+
+      analysis
+    end
+
+    # Monitor memory during a block execution
+    def self.monitor_memory(label, &block)
+      snapshot("before_#{label}")
+      result = yield
+      snapshot("after_#{label}")
+
+      # Get the difference
+      analysis = analyze_memory
+      if analysis[:memory_stats]
+        puts "🔍 Memory monitoring for '#{label}':"
+        puts "  - Memory change: #{analysis[:memory_stats][:max] - analysis[:memory_stats][:min]}MB"
+        puts "  - Peak usage: #{analysis[:memory_stats][:max]}MB"
+      end
+
+      result
+    end
+
+    # Clear memory history (useful for testing)
+    def self.clear_history
+      DeadBro::MemoryLeakDetector.clear_history
+    end
+
+    # Get top memory allocating classes
+    def self.top_allocators
+      # This would need to be called from within a request context
+      # where memory_events are available
+      puts "Top memory allocators:"
+      puts "  (Call this from within a request to see allocation data)"
+    end
+  end
+end