debug-agent 0.4.0 → 0.5.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 791b8f21395b061038d65dcae92007460556766622991c1c0a1692ae21b272f5
-  data.tar.gz: b57b2b97b9473da04c7b7fc3cf67729bddfc283e2ca71d34b4e6469d2c47e65a
+  metadata.gz: 6811d0a31e6c030eb3883ec27085c87cdaa7f9e0217e4e0e7b25cba7d3f2fc6b
+  data.tar.gz: a327319653c66f29a8099d468739c45e683b47891ffb7952b705a4ea016dcfc6
 SHA512:
-  metadata.gz: 7fd90445975ede4bbc7474c7a57e94e1914098d9c4743180fdcdb737611ef461f2a6034da40fd31eb101188c34a28a12ac056db119f510e3de37ac494e06b67b
-  data.tar.gz: acf3c742b54b5d8173e6908ec27e079cd66efd4063f515b9278ec8754ef84e1539bbe5e13d47c79d342c33046678b972b9c6873cb6c5c9c96618669209145fa2
+  metadata.gz: 3a8d3017f048ea920c9051e148b129e74da019693d12dff637ed023eecca16a97d82ef887d2943f6d5f2983968d4d8f5cd259da6513498fdc3653db5b36d42dd
+  data.tar.gz: 79429a53f7be512a9f58d69e4d0948a3e29bffe2f27ce06733154189ca54441e683337cf1ca57acbc58fefe86bd5236462e24371bc12646659a824832cbe4a63

data/README.md

@@ -1,11 +1,27 @@
 # Ruby Debug Agent
 
 [![Gem Version](https://img.shields.io/badge/gem-debug--agent-red)](https://github.com/topcheer/ruby-debug-agent)
-![Tools](https://img.shields.io/badge/tools-54-blue)
-![Inspectors](https://img.shields.io/badge/inspectors-20-green)
+![Tools](https://img.shields.io/badge/tools-67-blue)
+![Inspectors](https://img.shields.io/badge/inspectors-25-green)
+![Ruby](https://img.shields.io/badge/Ruby-2.7%2B-CC342D)
+![Gem](https://img.shields.io/badge/gem-debug--agent-red)
 
 An AI-powered runtime debugging agent that embeds directly into your Ruby application. Add one gem, configure an LLM key, and chat with your live app at `/agent` to inspect GC, ObjectSpace, threads, routes, Redis, Rails models/routes, Sidekiq queues, Puma stats, fibers/signals, process info, HTTP requests, and more — **54 diagnostic tools across 20 inspectors**.
 
+## Version Support
+
+| Ruby Version | Status |
+|--------------|--------|
+| 2.6          | Not supported |
+| 2.7          | Minimum supported |
+| 3.0          | Supported (Fiber.list available) |
+| 3.1          | Supported |
+| 3.2          | Supported |
+| 3.3          | Supported |
+| 3.4          | Tested |
+
+> Requires Ruby 2.7+ for pattern matching guards. Framework inspectors (Rails, Sidekiq, Puma) are optional and auto-detected via `defined?`.
+
 ## Quick Start
 
 ### 1. Install

data/lib/debug_agent/inspectors/error_tracking.rb

@@ -0,0 +1,120 @@
+require 'time'
+require 'thread'
+
+module DebugAgent
+  MAX_ERRORS = 50
+  @error_buffer = []
+  @error_buffer_lock = Mutex.new
+
+  class << self
+    attr_reader :error_buffer
+
+    def record_error(error, context = {})
+      @error_buffer_lock.synchronize do
+        @error_buffer << {
+          timestamp: Time.now.iso8601,
+          class: error.class.name,
+          message: error.message,
+          backtrace: (error.backtrace || []).first(10),
+          context: context
+        }
+        @error_buffer.shift if @error_buffer.size > MAX_ERRORS
+      end
+    end
+  end
+
+  # Capture unhandled exceptions at process exit
+  at_exit do
+    if $!
+      DebugAgent.record_error($!)
+    end
+  end
+
+  register_tool('get_recent_errors',
+                'Get recent unhandled exceptions captured by the agent (ring buffer, max 50). ' \
+                'Each entry: timestamp, class, message, backtrace',
+                limit: { type: 'integer', description: 'Maximum number of errors to return (default 20)', required: false }) do |limit: 20|
+    errors = @error_buffer_lock.synchronize { @error_buffer.dup }
+
+    if errors.empty?
+      next {
+        message: 'No errors captured yet. Errors are recorded via at_exit and when ' \
+                 'DebugAgent.record_error is called (e.g. from a Sinatra error handler).',
+        total: 0
+      }
+    end
+
+    limit = limit.to_i
+    limit = 20 if limit <= 0
+
+    { total: errors.size, errors: errors.reverse.first(limit) }
+  rescue => e
+    { error: e.message }
+  end
+
+  register_tool('get_error_stats',
+                'Get error statistics: total errors, rate per minute, and top error types') do
+    errors = @error_buffer_lock.synchronize { @error_buffer.dup }
+
+    if errors.empty?
+      next { total: 0, message: 'No errors captured yet.' }
+    end
+
+    # Group by error class
+    by_class = errors.group_by { |e| e[:class] }
+    top_types = by_class.map do |klass, entries|
+      { class: klass, count: entries.size, last_seen: entries.last[:timestamp] }
+    end.sort_by { |t| -t[:count] }
+
+    # Calculate rate per minute (errors in the last 60 seconds)
+    now = Time.now
+    recent = errors.select do |e|
+      begin
+        (now - Time.iso8601(e[:timestamp])) <= 60
+      rescue
+        false
+      end
+    end
+
+    {
+      total: errors.size,
+      buffer_capacity: MAX_ERRORS,
+      rate_per_minute: recent.size,
+      unique_error_types: by_class.size,
+      top_error_types: top_types.first(10),
+      first_error: errors.first[:timestamp],
+      last_error: errors.last[:timestamp]
+    }
+  rescue => e
+    { error: e.message }
+  end
+
+  register_tool('get_error_patterns',
+                'Group captured errors by exception class to identify recurring patterns') do
+    errors = @error_buffer_lock.synchronize { @error_buffer.dup }
+
+    if errors.empty?
+      next { total: 0, message: 'No errors captured yet.' }
+    end
+
+    patterns = errors.group_by { |e| e[:class] }.map do |klass, entries|
+      sample_messages = entries.map { |e| e[:message] }.uniq.first(5)
+      {
+        class: klass,
+        count: entries.size,
+        sample_messages: sample_messages,
+        first_seen: entries.first[:timestamp],
+        last_seen: entries.last[:timestamp],
+        sample_backtrace: entries.last[:backtrace]
+      }
+    end.sort_by { |p| -p[:count] }
+
+    {
+      total_errors: errors.size,
+      unique_patterns: patterns.size,
+      patterns: patterns
+    }
+  rescue => e
+    { error: e.message }
+  end
+end

data/lib/debug_agent/inspectors/health.rb

@@ -0,0 +1,110 @@
+module DebugAgent
+  # Registry of health check blocks. Each block returns a hash with at least
+  # a :status key ('UP', 'DOWN', or 'DEGRADED').
+  #
+  #   DebugAgent.register_health_check(:database) { { status: 'UP' } }
+  @health_checks = {}
+
+  class << self
+    attr_reader :health_checks
+
+    def register_health_check(name, &block)
+      @health_checks[name.to_s] = block
+    end
+  end
+
+  register_tool('get_health_status',
+                'Run all registered health checks and report status per component: UP, DOWN, or DEGRADED') do
+    if health_checks.empty?
+      next {
+        message: 'No health checks registered. Call DebugAgent.register_health_check(:name) { ... }.',
+        overall_status: 'UNKNOWN'
+      }
+    end
+
+    results = {}
+    up = 0
+    down = 0
+    degraded = 0
+
+    health_checks.each do |check_name, block|
+      begin
+        result = block.call
+        status = result.is_a?(Hash) ? (result[:status] || result['status'] || 'UP').to_s.upcase : 'UP'
+        results[check_name] = result.merge(status: status, latency_ms: nil)
+
+        case status
+        when 'UP' then up += 1
+        when 'DOWN' then down += 1
+        when 'DEGRADED' then degraded += 1
+        end
+      rescue => e
+        results[check_name] = { status: 'DOWN', error: e.message }
+        down += 1
+      end
+    end
+
+    overall = if down > 0
+      'DOWN'
+    elsif degraded > 0
+      'DEGRADED'
+    else
+      'UP'
+    end
+
+    {
+      overall_status: overall,
+      up: up,
+      down: down,
+      degraded: degraded,
+      total: health_checks.size,
+      components: results
+    }
+  rescue => e
+    { error: e.message }
+  end
+
+  register_tool('get_health_detail',
+                'Deep dive into a specific health check component for detailed diagnostics',
+                component_name: { type: 'string', description: 'Name of the health check component to inspect', required: true }) do |component_name:|
+    if health_checks.empty?
+      next { error: 'No health checks registered.' }
+    end
+
+    key = component_name.to_s
+    block = health_checks[key]
+    next { error: "No health check registered for '#{component_name}'. Available: #{health_checks.keys.join(', ')}" } unless block
+
+    # Run the check multiple times to measure latency
+    samples = []
+    3.times do
+      start = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      begin
+        result = block.call
+        elapsed = ((Process.clock_gettime(Process::CLOCK_MONOTONIC) - start) * 1000.0).round(2)
+        status = result.is_a?(Hash) ? (result[:status] || result['status'] || 'UP').to_s.upcase : 'UP'
+        samples << { status: status, latency_ms: elapsed, detail: result }
+      rescue => e
+        elapsed = ((Process.clock_gettime(Process::CLOCK_MONOTONIC) - start) * 1000.0).round(2)
+        samples << { status: 'DOWN', latency_ms: elapsed, error: e.message }
+        break
+      end
+    end
+
+    latencies = samples.map { |s| s[:latency_ms] }
+
+    {
+      component: key,
+      registered_checks: health_checks.keys,
+      latest: samples.last,
+      samples: samples.size,
+      latency_ms: {
+        min: latencies.min,
+        avg: (latencies.sum / latencies.size.to_f).round(2),
+        max: latencies.max
+      }
+    }
+  rescue => e
+    { error: e.message }
+  end
+end

data/lib/debug_agent/inspectors/scheduler.rb

@@ -0,0 +1,154 @@
+module DebugAgent
+  # Registry of scheduled jobs (Sidekiq::Cron, rufus-scheduler, whenever, or
+  # custom Thread-based timers). Applications register jobs so the inspector
+  # can list them and report execution history.
+  #
+  #   DebugAgent.register_scheduled_job(:cleanup, 'every 30s', last_run: Time.now)
+  @scheduled_jobs = {}
+  @job_history = {}
+  @scheduler_lock = Mutex.new
+
+  class << self
+    attr_reader :scheduled_jobs, :job_history
+
+    def register_scheduled_job(name, schedule, **opts)
+      @scheduled_jobs[name.to_s] = {
+        schedule: schedule,
+        name: name.to_s,
+        class: opts[:class] || name.to_s,
+        queue: opts[:queue],
+        enabled: opts.key?(:enabled) ? opts[:enabled] : true,
+        last_run: opts[:last_run],
+        next_run: opts[:next_run],
+        registered_at: Time.now
+      }
+    end
+
+    # Record a job execution for history tracking.
+    def record_job_execution(name, duration_ms, success: true, error: nil)
+      @scheduler_lock.synchronize do
+        history = (@job_history[name.to_s] ||= [])
+        history << {
+          timestamp: Time.now.iso8601,
+          duration_ms: duration_ms.round(2),
+          success: success,
+          error: error
+        }
+        history.shift if history.size > 100
+
+        # Update last_run on the job itself
+        if @scheduled_jobs[name.to_s]
+          @scheduled_jobs[name.to_s][:last_run] = Time.now
+        end
+      end
+    end
+  end
+
+  register_tool('get_scheduled_jobs',
+                'List scheduled jobs from Sidekiq::Cron, rufus-scheduler, whenever, ' \
+                'or custom Thread-based timers. Shows schedule, last run, and status') do
+    jobs = []
+
+    # Registered jobs (Thread-based, custom, etc.)
+    scheduled_jobs.each do |name, job|
+      jobs << {
+        name: name,
+        schedule: job[:schedule],
+        class: job[:class],
+        queue: job[:queue],
+        enabled: job[:enabled],
+        source: job[:source] || 'registered',
+        last_run: job[:last_run],
+        next_run: job[:next_run]
+      }
+    end
+
+    # Sidekiq::Cron jobs
+    if defined?(::Sidekiq::Cron::Job)
+      begin
+        ::Sidekiq::Cron::Job.all.each do |cron_job|
+          jobs << {
+            name: cron_job.name,
+            schedule: cron_job.cron,
+            class: cron_job.klass,
+            queue: cron_job.queue_name,
+            enabled: cron_job.status == 'enabled',
+            source: 'sidekiq-cron',
+            last_run: cron_job.last_enqueue_time
+          }
+        end
+      rescue => e
+        jobs << { source: 'sidekiq-cron', error: e.message }
+      end
+    end
+
+    # rufus-scheduler
+    if defined?(::Rufus::Scheduler)
+      begin
+        ObjectSpace.each_object(::Rufus::Scheduler) do |scheduler|
+          scheduler.jobs.each do |job|
+            jobs << {
+              name: job.respond_to?(:tags) ? job.tags.first : nil,
+              schedule: job.respond_to?(:original) ? job.original : job.class.name,
+              class: job.class.name,
+              enabled: !job.respond_to?(:paused?) || !job.paused?,
+              source: 'rufus-scheduler',
+              last_run: job.respond_to?(:last_time) ? job.last_time : nil,
+              next_run: job.respond_to?(:next_time) ? job.next_time : nil
+            }
+          end
+        end
+      rescue => e
+        jobs << { source: 'rufus-scheduler', error: e.message }
+      end
+    end
+
+    if jobs.empty?
+      next {
+        message: 'No scheduled jobs registered. Call DebugAgent.register_scheduled_job(:name, schedule). ' \
+                 'Also auto-detects Sidekiq::Cron and rufus-scheduler if loaded.',
+        total: 0
+      }
+    end
+
+    { total: jobs.size, jobs: jobs }
+  rescue => e
+    { error: e.message }
+  end
+
+  register_tool('get_job_history',
+                'Get recent execution history for scheduled jobs: run times, duration, success/failure',
+                job_name: { type: 'string', description: 'Job name to filter history (optional, returns all if omitted)', required: false }) do |job_name: nil|
+    if job_history.empty?
+      next { message: 'No job execution history recorded. Jobs must call DebugAgent.record_job_execution to track history.', total: 0 }
+    end
+
+    if job_name
+      key = job_name.to_s
+      history = job_history[key] || []
+      next {
+        job: key,
+        total: history.size,
+        history: history.reverse.first(50)
+      }
+    end
+
+    all = job_history.map do |name, entries|
+      successful = entries.count { |e| e[:success] }
+      failed = entries.count { |e| !e[:success] }
+      durations = entries.map { |e| e[:duration_ms] }
+      {
+        job: name,
+        total_runs: entries.size,
+        successful: successful,
+        failed: failed,
+        avg_duration_ms: durations.empty? ? 0 : (durations.sum / durations.size.to_f).round(2),
+        last_run: entries.last&.dig(:timestamp)
+      }
+    end
+
+    { total_jobs: all.size, total_runs: job_history.values.map(&:size).sum, jobs: all }
+  rescue => e
+    { error: e.message }
+  end
+end

data/lib/debug_agent/inspectors/security.rb

@@ -0,0 +1,201 @@
+module DebugAgent
+  # Registry of auth configurations (Devise, Warden, OmniAuth, Rack auth).
+  #
+  #   DebugAgent.register_auth_config(:api_key, { strategy: 'X-API-Key', secret_present: true })
+  @auth_configs = {}
+
+  # Registry of session stores (Rack::Session, ActiveRecord::Session, custom).
+  #
+  #   DebugAgent.register_session_store(:rack_session, env['rack.session'])
+  @session_stores = {}
+
+  class << self
+    attr_reader :auth_configs, :session_stores
+
+    def register_auth_config(name, config)
+      @auth_configs[name.to_s] = config
+    end
+
+    def register_session_store(name, store)
+      @session_stores[name.to_s] = store
+    end
+  end
+
+  register_tool('get_auth_config',
+                'List registered auth configurations (Devise, Warden, OmniAuth, Rack auth). ' \
+                'Shows strategy, whether a secret is present, and token expiry') do |name: nil|
+    # Auto-detect from loaded gems when nothing is registered
+    if auth_configs.empty?
+      auto = {}
+      if defined?(::Devise)
+        auto['Devise'] = {
+          strategy: 'Devise',
+          secret_present: defined?(Devise.secret_key) && !Devise.secret_key.to_s.empty?,
+          models: (Devise.mappings.keys.map(&:to_s) rescue []),
+          token_expiry: nil
+        }
+      end
+      if defined?(::Warden)
+        auto['Warden'] = {
+          strategy: 'Warden',
+          secret_present: !!(Warden::Manager.respond_to?(:secret) rescue false),
+          default_strategies: (Warden::Config.new.default_strategies rescue []),
+          token_expiry: nil
+        }
+      end
+      if defined?(::OmniAuth)
+        auto['OmniAuth'] = {
+          strategy: 'OmniAuth',
+          providers: (OmniAuth.strategies.map(&:to_s) rescue []),
+          secret_present: !!(OmniAuth.configuration rescue nil),
+          token_expiry: nil
+        }
+      end
+      if auto.any?
+        next { auth_configs: auto, source: 'auto-detected' }
+      end
+      next { error: 'No auth configs registered. Call DebugAgent.register_auth_config(:name, config).' }
+    end
+
+    targets = name ? { name.to_s => auth_configs[name.to_s] } : auth_configs
+    targets = targets.reject { |_, c| c.nil? }
+    next { error: "No auth config registered under '#{name}'" } if targets.empty?
+
+    results = targets.map do |cfg_name, cfg|
+      begin
+        if cfg.is_a?(Hash)
+          normalized = {
+            name: cfg_name,
+            strategy: cfg[:strategy] || cfg['strategy'],
+            secret_present: cfg.key?(:secret_present) ? cfg[:secret_present] : cfg['secret_present'],
+            token_expiry: cfg[:token_expiry] || cfg['token_expiry']
+          }.merge(cfg.reject { |k, _| %i[strategy secret_present token_expiry].include?(k.to_sym) })
+          normalized
+        else
+          { name: cfg_name, type: cfg.class.name, raw: cfg.inspect }
+        end
+      rescue => e
+        { name: cfg_name, error: e.message }
+      end
+    end
+
+    { auth_configs: results }
+  rescue => e
+    { error: e.message }
+  end
+
+  register_tool('get_active_sessions',
+                'List active sessions from registered session stores ' \
+                '(Rack::Session, ActiveRecord::Session). ' \
+                'Shows session ID, user, creation, and expiry') do |name: nil|
+    if session_stores.empty?
+      next { error: 'No session stores registered. Call DebugAgent.register_session_store(:name, store).' }
+    end
+
+    targets = name ? { name.to_s => session_stores[name.to_s] } : session_stores
+    targets = targets.reject { |_, s| s.nil? }
+    next { error: "No session store registered under '#{name}'" } if targets.empty?
+
+    results = targets.map do |store_name, store|
+      begin
+        introspect_session_store(store_name, store)
+      rescue => e
+        { name: store_name, error: e.message }
+      end
+    end
+
+    { session_stores: results }
+  rescue => e
+    { error: e.message }
+  end
+
+  register_tool('get_cors_config',
+                'Show CORS settings (Rack::Cors config: allowed origins, methods, headers)') do
+    # Try to find Rack::Cors middleware in the app middleware stack
+    cors_rules = []
+
+    if app && app.respond_to?(:middleware)
+      app.middleware.each do |middleware_entry|
+        middleware_class = middleware_entry.shift if middleware_entry.is_a?(Array)
+        next unless middleware_class.to_s.include?('Cors')
+
+        args = middleware_entry || []
+        cors_rules << { middleware: middleware_class.to_s, args: args.inspect }
+      end
+    end
+
+    # Try Rack::Cors introspection
+    if defined?(::Rack::Cors)
+      begin
+        rack_cors = ::Rack::Cors
+        cors_rules << { middleware: 'Rack::Cors', version: rack_cors.respond_to?(:VERSION) ? rack_cors::VERSION : 'unknown' }
+      rescue => e
+        cors_rules << { middleware: 'Rack::Cors', error: e.message }
+      end
+    end
+
+    if cors_rules.empty?
+      next {
+        message: 'No CORS configuration detected. Install rack-cors and configure Rack::Cors middleware, ' \
+                 'or the inspector could not find CORS rules in the middleware stack.',
+        cors_enabled: false
+      }
+    end
+
+    { cors_enabled: true, rules: cors_rules }
+  rescue => e
+    { error: e.message }
+  end
+
+  # --- Helpers ---
+
+  def self.introspect_session_store(store_name, store)
+    info = { name: store_name, type: store.class.name }
+
+    # Rack::Session::Abstract::SessionHash or similar
+    if store.respond_to?(:to_hash)
+      begin
+        data = store.to_hash
+        info[:session_count] = data.size
+        info[:keys] = data.keys.first(50)
+        info[:has_user] = data.key?('user_id') || data.key?(:user_id) || data.key?('user')
+      rescue
+        info[:session_count] = 'unable to read'
+      end
+    end
+
+    # ActiveRecord::SessionStore
+    if store.respond_to?(:all)
+      begin
+        sessions = store.all.to_a
+        info[:session_count] = sessions.size
+        info[:sessions] = sessions.first(20).map do |sess|
+          sess_data = begin
+            sess.respond_to?(:data) ? sess.data.keys : []
+          rescue
+            []
+          end
+          {
+            session_id: sess.respond_to?(:session_id) ? sess.session_id : sess.id,
+            data: sess_data,
+            created_at: sess.respond_to?(:created_at) ? sess.created_at : nil,
+            updated_at: sess.respond_to?(:updated_at) ? sess.updated_at : nil
+          }
+        end
+      rescue
+        info[:session_count] = 'unable to read'
+      end
+    end
+
+    # Generic session store with session_id method
+    if store.respond_to?(:session_id)
+      begin
+        info[:session_id] = store.session_id
+      rescue
+        # ignore
+      end
+    end
+
+    info
+  end
+end

data/lib/debug_agent/inspectors/websocket.rb

@@ -0,0 +1,188 @@
+require 'time'
+require 'thread'
+
+module DebugAgent
+  # Registry of WebSocket servers (faye-websocket, websocket-driver, ActionCable).
+  # Applications register WS server objects so the inspector can introspect them.
+  #
+  #   DebugAgent.register_ws_server(:faye, ws_server)
+  @ws_servers = {}
+  @ws_connections = []
+  @ws_lock = Mutex.new
+  @ws_message_log = []
+
+  class << self
+    attr_reader :ws_servers, :ws_connections, :ws_message_log
+
+    def register_ws_server(name, server)
+      @ws_servers[name.to_s] = server
+    end
+
+    # Track a WebSocket connection
+    def track_ws_connection(conn_id, remote_addr, channel = nil)
+      @ws_lock.synchronize do
+        @ws_connections << {
+          id: conn_id,
+          remote_addr: remote_addr,
+          channel: channel,
+          connected_since: Time.now.iso8601,
+          messages_sent: 0,
+          messages_received: 0
+        }
+      end
+      conn_id
+    end
+
+    # Remove a tracked WebSocket connection
+    def untrack_ws_connection(conn_id)
+      @ws_lock.synchronize do
+        @ws_connections.reject! { |c| c[:id] == conn_id }
+      end
+    end
+
+    # Log a WebSocket message
+    def log_ws_message(conn_id, direction, data, size = nil)
+      @ws_lock.synchronize do
+        @ws_message_log << {
+          timestamp: Time.now.iso8601,
+          connection_id: conn_id,
+          direction: direction, # 'sent' or 'received'
+          size: size || data.to_s.bytesize,
+          preview: data.to_s[0...200]
+        }
+        @ws_message_log.shift if @ws_message_log.size > 200
+
+        conn = @ws_connections.find { |c| c[:id] == conn_id }
+        if conn
+          if direction == 'sent'
+            conn[:messages_sent] += 1
+          else
+            conn[:messages_received] += 1
+          end
+        end
+      end
+    end
+  end
+
+  register_tool('get_ws_connections',
+                'Get active WebSocket connections (faye-websocket, websocket-driver, ActionCable). ' \
+                'Shows connection ID, remote address, connected since, and message counts') do
+    conns = @ws_lock.synchronize { @ws_connections.dup }
+
+    # Also try to auto-detect ActionCable connections
+    if defined?(::ActionCable)
+      begin
+        server = ::ActionCable.server
+        if server && server.respond_to?(:connections)
+          server.connections.each do |conn|
+            next if conns.any? { |c| c[:id] == conn.object_id }
+            conns << {
+              id: conn.object_id,
+              remote_addr: conn.respond_to?(:env) ? (conn.env['REMOTE_ADDR'] rescue 'unknown') : 'unknown',
+              channel: 'ActionCable',
+              connected_since: nil,
+              messages_sent: conn.respond_to?(:transmissions) ? conn.transmissions : nil,
+              messages_received: nil,
+              source: 'actioncable'
+            }
+          end
+        end
+      rescue => e
+        conns << { source: 'actioncable', error: e.message }
+      end
+    end
+
+    if conns.empty?
+      next {
+        message: 'No WebSocket connections tracked. Register with DebugAgent.register_ws_server ' \
+                 'or DebugAgent.track_ws_connection. Auto-detects ActionCable if loaded.',
+        total: 0
+      }
+    end
+
+    { total: conns.size, connections: conns }
+  rescue => e
+    { error: e.message }
+  end
+
+  register_tool('get_ws_stats',
+                'Get WebSocket statistics: total connections, total messages, ' \
+                'messages per connection, uptime') do
+    conns = @ws_lock.synchronize { @ws_connections.dup }
+    msgs = @ws_lock.synchronize { @ws_message_log.dup }
+
+    if conns.empty? && msgs.empty?
+      next { total_connections: 0, total_messages: 0, message: 'No WebSocket activity recorded.' }
+    end
+
+    sent = conns.sum { |c| c[:messages_sent] || 0 }
+    received = conns.sum { |c| c[:messages_received] || 0 }
+    total_bytes = msgs.sum { |m| m[:size] || 0 }
+
+    {
+      total_connections: conns.size,
+      total_messages_sent: sent,
+      total_messages_received: received,
+      total_messages: sent + received,
+      total_bytes: total_bytes,
+      avg_messages_per_connection: conns.empty? ? 0 : ((sent + received).to_f / conns.size).round(2),
+      registered_servers: ws_servers.keys,
+      recent_messages: msgs.reverse.first(20)
+    }
+  rescue => e
+    { error: e.message }
+  end
+
+  register_tool('get_ws_channels',
+                'Get WebSocket channels with subscriber counts (ActionCable channels or custom pub/sub)') do
+    channels = []
+
+    # Auto-detect ActionCable channels
+    if defined?(::ActionCable::Channel::Base)
+      begin
+        # Look for channel subclasses
+        channel_classes = []
+        ObjectSpace.each_object(Class) do |klass|
+          if klass < ::ActionCable::Channel::Base && klass != ::ActionCable::Channel::Base
+            channel_classes << klass
+          end
+        end
+
+        channel_classes.uniq.each do |klass|
+          channels << {
+            name: klass.name,
+            source: 'actioncable',
+            subscribers: 0 # ActionCable doesn't expose per-channel counts easily
+          }
+        end
+      rescue => e
+        channels << { source: 'actioncable', error: e.message }
+      end
+    end
+
+    # Track connections grouped by channel from our own registry
+    @ws_lock.synchronize do
+      by_channel = @ws_connections.group_by { |c| c[:channel] || 'default' }
+      by_channel.each do |channel, conns|
+        existing = channels.find { |ch| ch[:name] == channel }
+        if existing
+          existing[:subscribers] = conns.size
+        else
+          channels << { name: channel, source: 'tracked', subscribers: conns.size }
+        end
+      end
+    end
+
+    if channels.empty?
+      next {
+        message: 'No WebSocket channels found. Define ActionCable channels or use ' \
+                 'DebugAgent.track_ws_connection with a channel name.',
+        total: 0
+      }
+    end
+
+    { total: channels.size, channels: channels }
+  rescue => e
+    { error: e.message }
+  end
+end

data/lib/debug_agent/llm_client.rb

@@ -83,72 +83,72 @@ module DebugAgent
 
     def stream_request(path, body, handler)
       uri = URI(@cfg.base_url + path)
-      http = Net::HTTP.new(uri.host, uri.port)
-      http.use_ssl = uri.scheme == 'https'
-      http.read_timeout = @cfg.timeout_seconds
 
-      request = Net::HTTP::Post.new(uri.path)
-      request['Authorization'] = "Bearer #{@cfg.api_key}"
-      request['Content-Type'] = 'application/json'
-      request.body = JSON.generate(body)
-
-      response = http.request(request)
-
-      if response.code.to_i >= 400
-        raise RetriableError.new(response.code.to_i, "HTTP #{response.code}: #{response.body}")
-      end
+      Net::HTTP.start(uri.host, uri.port, use_ssl: uri.scheme == 'https', read_timeout: @cfg.timeout_seconds) do |http|
+        request = Net::HTTP::Post.new(uri.path)
+        request['Authorization'] = "Bearer #{@cfg.api_key}"
+        request['Content-Type'] = 'application/json'
+        request.body = JSON.generate(body)
 
-      tool_call_map = {}
-      finish_reason = nil
-      usage = nil
+        tool_call_map = {}
+        finish_reason = nil
+        usage = nil
 
-      response.read_body do |chunk|
-        chunk.split("\n").each do |line|
-          next unless line.start_with?('data: ')
-
-          data_str = line[6..]
-          next if data_str.strip == '[DONE]'
-
-          begin
-            parsed = JSON.parse(data_str)
-          rescue JSON::ParserError
-            next
-          end
-
-          if parsed['usage'] && parsed['usage']['prompt_tokens']
-            usage = parsed['usage']
-          end
-
-          choices = parsed['choices'] || []
-          next if choices.empty?
-
-          choice = choices[0]
-          delta = choice['delta'] || {}
-
-          if delta['content'] && !delta['content'].empty?
-            handler.on_content(delta['content'])
+        http.request(request) do |response|
+          if response.code.to_i >= 400
+            err_body = response.read_body
+            raise RetriableError.new(response.code.to_i, "HTTP #{response.code}: #{err_body}")
           end
 
-          if delta['tool_calls']
-            delta['tool_calls'].each do |tc|
-              idx = tc['index'] || 0
-              tool_call_map[idx] ||= { 'id' => '', 'type' => 'function', 'function' => { 'name' => '', 'arguments' => '' } }
-              entry = tool_call_map[idx]
-              entry['id'] = tc['id'] if tc['id']
-              entry['type'] = tc['type'] if tc['type']
-              fn = tc['function'] || {}
-              entry['function']['name'] += fn['name'] if fn['name']
-              entry['function']['arguments'] += fn['arguments'] if fn['arguments']
+          response.read_body do |chunk|
+            chunk.split("\n").each do |line|
+              next unless line.start_with?('data: ')
+
+              data_str = line[6..]
+              next if data_str.strip == '[DONE]'
+
+              begin
+                parsed = JSON.parse(data_str)
+              rescue JSON::ParserError
+                next
+              end
+
+              if parsed['usage'] && parsed['usage']['prompt_tokens']
+                usage = parsed['usage']
+              end
+
+              choices = parsed['choices'] || []
+              next if choices.empty?
+
+              choice = choices[0]
+              delta = choice['delta'] || {}
+
+              if delta['content'] && !delta['content'].empty?
+                handler.on_content(delta['content'])
+              end
+
+              if delta['tool_calls']
+                delta['tool_calls'].each do |tc|
+                  idx = tc['index'] || 0
+                  tool_call_map[idx] ||= { 'id' => '', 'type' => 'function', 'function' => { 'name' => '', 'arguments' => '' } }
+                  entry = tool_call_map[idx]
+                  entry['id'] = tc['id'] if tc['id']
+                  entry['type'] = tc['type'] if tc['type']
+                  fn = tc['function'] || {}
+                  entry['function']['name'] += fn['name'] if fn['name']
+                  entry['function']['arguments'] += fn['arguments'] if fn['arguments']
+                end
+              end
+
+              finish_reason = choice['finish_reason'] if choice['finish_reason']
             end
           end
-
-          finish_reason = choice['finish_reason'] if choice['finish_reason']
         end
-      end
 
-      tool_calls = tool_call_map.keys.sort.map { |k| tool_call_map[k] }.select { |tc| tc['function']['name'] && !tc['function']['name'].empty? }
+        tool_calls = tool_call_map.keys.sort.map { |k| tool_call_map[k] }.select { |tc| tc['function']['name'] && !tc['function']['name'].empty? }
 
-      handler.on_complete(tool_calls, finish_reason, usage)
+        handler.on_complete(tool_calls, finish_reason, usage)
+      end
     end
 
     # ==================== Non-Streaming POST with retry ====================

data/lib/debug_agent/version.rb

@@ -1,3 +1,3 @@
 module DebugAgent
-  VERSION = '0.4.0'.freeze
+  VERSION = '0.5.1'.freeze
 end

data/lib/debug_agent.rb

@@ -30,6 +30,11 @@ require_relative 'debug_agent/inspectors/metrics'
 require_relative 'debug_agent/inspectors/active_record_stats'
 require_relative 'debug_agent/inspectors/faraday'
 require_relative 'debug_agent/inspectors/concurrent'
+require_relative 'debug_agent/inspectors/security'
+require_relative 'debug_agent/inspectors/health'
+require_relative 'debug_agent/inspectors/scheduler'
+require_relative 'debug_agent/inspectors/error_tracking'
+require_relative 'debug_agent/inspectors/websocket'
 
 module DebugAgent
   class Error < StandardError; end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: debug-agent
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.5.1
 platform: ruby
 authors:
 - ggcode
@@ -168,8 +168,10 @@ files:
 - lib/debug_agent/inspectors/cache.rb
 - lib/debug_agent/inspectors/concurrent.rb
 - lib/debug_agent/inspectors/core_ext.rb
+- lib/debug_agent/inspectors/error_tracking.rb
 - lib/debug_agent/inspectors/faraday.rb
 - lib/debug_agent/inspectors/gc.rb
+- lib/debug_agent/inspectors/health.rb
 - lib/debug_agent/inspectors/http_client.rb
 - lib/debug_agent/inspectors/http_tracker.rb
 - lib/debug_agent/inspectors/logging.rb
@@ -181,9 +183,12 @@ files:
 - lib/debug_agent/inspectors/redis.rb
 - lib/debug_agent/inspectors/routes.rb
 - lib/debug_agent/inspectors/runtime.rb
+- lib/debug_agent/inspectors/scheduler.rb
+- lib/debug_agent/inspectors/security.rb
 - lib/debug_agent/inspectors/sidekiq.rb
 - lib/debug_agent/inspectors/system.rb
 - lib/debug_agent/inspectors/threads.rb
+- lib/debug_agent/inspectors/websocket.rb
 - lib/debug_agent/llm_client.rb
 - lib/debug_agent/middleware.rb
 - lib/debug_agent/system_prompt_builder.rb