debug-agent 0.2.6 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 282c047d0e86a70412110ecbd1a3579ee8a71af4b2743de37a4769242df6b634
-  data.tar.gz: ba97cf4ae8a5757f70c5bf261e5b5b34fb5d752a5543e9b4c657db5fdfc299bf
+  metadata.gz: 94cb18c1904795fb713e2486d5f6d16e1bbce1a72d1820dd4122b2b7bc672a4d
+  data.tar.gz: 8cf474737f8b84aa5f2a20e5d07f13a02c7345df6805d6b075f72bbb5175fc4f
 SHA512:
-  metadata.gz: 0b68399b6dd5fe9d83f9369a9ab896bde2c2d6941a3d8d531b6721427f21b96643e9e8b3793a7da31984b34da7ed79779ba43a30bcbf57e6c20b8451831482f0
-  data.tar.gz: c4dc62c89f4bfd0100dae01b636130cc0316b5bc1f2981db85d52a8e360a997bf755851187719be8a88f4e05faf443bbc7c535d83b29011ba4c4b2fd8582cb89
+  metadata.gz: 48c72eaf044cb325c3d8cb9e5ddc5afabbf85f5830e675795e8afb34182db5eb381f90ce913af411b4cf4acb662f82bf23373f2c12785e3dcee0a2491624e2a6
+  data.tar.gz: 20e31311478fd6e5a54e0f693ce5a3cddc27952e5816a56082050bf17e77e4b19aba10d74bde0e95689765ec9e851228c0921724bb566f7609848ab76a844d79

data/README.md

@@ -1,6 +1,10 @@
 # Ruby Debug Agent
 
-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, process info, HTTP requests, and more.
+[![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-40-blue)
+![Inspectors](https://img.shields.io/badge/inspectors-13-green)
+
+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 — **40 diagnostic tools across 13 inspectors**.
 
 ## Quick Start
 
@@ -51,9 +55,10 @@ http://localhost:4567/agent
 - **Context compression** — automatically summarizes old conversation when token limit is approached
 - **Dark-themed chat UI** with full markdown rendering (tables, code blocks, lists)
 - **Max tool rounds** (25) with forced final summary when limit is reached
-- **26 diagnostic tools** across 8 inspectors
+- **40 diagnostic tools** across **13 inspectors**
+- Zero external dependencies (no Datadog, no Grafana, no APM)
 
-## Inspectors & Tools (26)
+## Inspectors & Tools (40)
 
 ### GC Inspector
 | Tool | Description |
@@ -75,6 +80,7 @@ http://localhost:4567/agent
 | `get_thread_list` | List all threads with status and backtrace summary |
 | `get_thread_count` | Thread count |
 | `get_main_thread_info` | Main thread priority, status |
+| `get_thread_backtrace` | Full backtrace for a specific thread |
 
 ### Route Inspector
 | Tool | Description |
@@ -88,6 +94,7 @@ http://localhost:4567/agent
 | `get_process_info` | PID, ppid, platform, Ruby version, uptime |
 | `get_cpu_time` | Process.times() user/sys CPU time |
 | `get_environment_variables` | Environment variables (masked secrets) |
+| `get_process_memory` | Process RSS, VMS, and memory growth trend |
 
 ### Runtime Inspector
 | Tool | Description |
@@ -108,9 +115,43 @@ http://localhost:4567/agent
 | Tool | Description |
 |------|-------------|
 | `get_system_info` | Hostname, CPU cores, disk |
-| `get_disk_usage` | Disk usage for working directory |
+| `get_disk_usage` | Disk usage for the working directory |
 | `get_file_descriptors` | Open file descriptor count |
 
+### Redis Inspector
+| Tool | Description |
+|------|-------------|
+| `get_redis_info` | Redis server info: memory, clients, persistence |
+| `get_redis_keys` | Scan Redis keyspace with pattern matching |
+| `get_redis_slowlog` | Redis slow query log entries |
+| `get_redis_stats` | Per-command call count, hit/miss ratio, keyspace stats |
+
+### Rails Inspector
+| Tool | Description |
+|------|-------------|
+| `get_rails_models` | List ActiveRecord models with table names and associations |
+| `get_rails_routes` | List Rails routes with helper names and HTTP verbs |
+| `get_rails_db_schema` | Database schema version and pending migrations |
+
+### Sidekiq Inspector
+| Tool | Description |
+|------|-------------|
+| `get_sidekiq_queues` | Queue list with depth, latency, and size |
+| `get_sidekiq_workers` | Active Sidekiq workers with job and host info |
+| `get_sidekiq_jobs` | Inspect jobs in a queue/retry set with payload |
+
+### Puma Inspector
+| Tool | Description |
+|------|-------------|
+| `get_puma_stats` | Puma cluster stats: workers, threads, running/backlog, boot time |
+
+### Fibers/Signals Inspector
+| Tool | Description |
+|------|-------------|
+| `get_fiber_list` | List active Ruby Fibers with state and backtrace |
+| `get_signal_handlers` | List registered signal handlers (Signal.trap) |
+| `get_trap_handlers` | Inspect trap handlers for SIGINT, SIGTERM, etc. |
+
 ## Custom Tools
 
 ```ruby
@@ -133,12 +174,36 @@ end
 
 ## Run the Demo
 
+The demo uses **Sinatra** + **redis-rb** + **SQLite** + **Sidekiq**. Start Redis with Docker Compose first:
+
+### Docker Compose
+
+```yaml
+# docker-compose.yml
+services:
+  redis:
+    image: redis:7-alpine
+    ports:
+      - "6379:6379"
+    command: redis-server --save 60 1 --loglevel warning
+```
+
+```bash
+docker compose up -d
+```
+
+### Start the app
+
 ```bash
 export LLM_API_KEY=your-key
 cd demo && ruby -I../lib app.rb
 # Open http://localhost:4567/agent
 ```
 
+## RubyGems
+
+[![Gem](https://img.shields.io/badge/rubygems-debug--agent-red)](https://github.com/topcheer/ruby-debug-agent)
+
 ## License
 
 MIT

data/lib/debug_agent/inspectors/core_ext.rb

@@ -0,0 +1,105 @@
+module DebugAgent
+  register_tool('get_fiber_info',
+                'List alive fibers (Ruby 3.0+ via Fiber.list) with status and backtrace') do
+    unless Fiber.respond_to?(:list)
+      return {
+        supported: false,
+        message: 'Fiber.list requires Ruby 3.0+. ' \
+          "Current Ruby: #{RUBY_VERSION} (#{RUBY_ENGINE})"
+      }
+    end
+
+    fibers = Fiber.list.map do |fiber|
+      backtrace =
+        begin
+          fiber.backtrace || []
+        rescue => e
+          ["<unable to get backtrace: #{e.message}>"]
+        end
+
+      {
+        object_id: fiber.object_id,
+        to_s: fiber.to_s,
+        alive: fiber.alive?,
+        resizable: fiber.respond_to?(:resizable?) ? fiber.resizable? : nil,
+        storage: fiber.respond_to?(:storage) ? (fiber.storage&.keys&.map(&:to_s) rescue nil) : nil,
+        backtrace_summary: backtrace.first(5),
+        backtrace_length: backtrace.size
+      }
+    end
+
+    {
+      supported: true,
+      total_fibers: fibers.size,
+      alive_fibers: fibers.count { |f| f[:alive] },
+      fibers: fibers
+    }
+  rescue => e
+    { error: e.message }
+  end
+
+  register_tool('get_signal_handlers',
+                'List registered signal handlers (Signal.trap) and default handlers') do
+    handlers = []
+
+    Signal.list.each do |name, number|
+      begin
+        current = Signal.trap(name)
+      rescue => e
+        current = "<error: #{e.message}>"
+      end
+
+      handlers << {
+        signal: name,
+        number: number,
+        handler:
+          case current
+          when 'DEFAULT' then 'DEFAULT (system default)'
+          when 'IGNORE'  then 'IGNORE (ignored)'
+          when 'EXIT'    then 'EXIT (terminate process)'
+          when 'SYSTEM_DEFAULT' then 'SYSTEM_DEFAULT'
+          when String then current
+          when Proc
+            begin
+              src = current.source_location
+              src ? "Proc at #{src.join(':')}" : 'Proc (unknown source)'
+            rescue
+              'Proc'
+            end
+          else
+            current.inspect
+          end
+      }
+    end
+
+    {
+      total_signals: handlers.size,
+      signals: handlers.sort_by { |h| h[:number] }
+    }
+  rescue => e
+    { error: e.message }
+  end
+
+  register_tool('get_encoding_info',
+                'Get Ruby encoding info: Encoding.list, default external/internal/locale encodings') do
+    list = Encoding.list.map do |enc|
+      {
+        name: enc.name,
+        aliases: Encoding.aliases.select { |_, n| n == enc.name }.keys,
+        dummy: enc.dummy?,
+        ascii_compatible: enc.ascii_compatible?
+      }
+    end
+
+    {
+      total_encodings: list.size,
+      default_external: Encoding.default_external.to_s,
+      default_internal: Encoding.default_internal&.to_s,
+      locale: Encoding.find('locale').to_s,
+      filesystem: Encoding.find('filesystem').to_s,
+      encodings: list
+    }
+  rescue => e
+    { error: e.message }
+  end
+end

data/lib/debug_agent/inspectors/puma.rb

@@ -0,0 +1,73 @@
+module DebugAgent
+  register_tool('get_puma_stats',
+                'Get Puma worker stats: running workers, threads, backlog, requests ' \
+                '(uses Puma.stats if Puma is loaded)') do
+    unless defined?(::Puma)
+      return { error: 'Puma is not loaded (puma gem not installed)' }
+    end
+
+    raw =
+      if ::Puma.respond_to?(:stats_hash)
+        ::Puma.stats_hash
+      elsif ::Puma.respond_to?(:stats)
+        # Puma.stats returns a JSON string in older versions; parse it.
+        s = ::Puma.stats
+        s.is_a?(String) ? JSON.parse(s, symbolize_names: true) : s
+      else
+        return { error: 'Puma is loaded but does not expose Puma.stats' }
+      end
+
+    raw = raw.respond_to?(:transform_keys) ? raw : raw
+
+    # Normalize into a structured summary.
+    workers = []
+
+    # Clustered mode: raw is { workers: N, booted_workers: N, old_workers: N,
+    #                          phase: N, worker_status: [...] }
+    # Single mode: raw is { backed_up: N, running: N, pool_capacity: N,
+    #                         max_threads: N, requests_count: N }
+    if raw.is_a?(Hash) && raw.key?(:worker_status)
+      raw[:worker_status].each_with_index do |w, i|
+        last_stats = w[:last_status] || {}
+        workers << {
+          index: i,
+          pid: w[:pid],
+          index_field: w[:index],
+          booted: w[:booted],
+          last_checkin: w[:last_checkin],
+          running_threads: last_stats[:running],
+          pool_capacity: last_stats[:pool_capacity],
+          max_threads: last_stats[:max_threads],
+          backlog: last_stats[:backed_up],
+          requests: last_stats[:requests_count]
+        }
+      end
+
+      {
+        mode: 'cluster',
+        configured_workers: raw[:workers],
+        booted_workers: raw[:booted_workers],
+        old_workers: raw[:old_workers],
+        phase: raw[:phase],
+        workers: workers,
+        total_running_threads: workers.sum { |w| w[:running_threads].to_i },
+        total_backlog: workers.sum { |w| w[:backlog].to_i },
+        total_requests: workers.sum { |w| w[:requests].to_i }
+      }
+    elsif raw.is_a?(Hash)
+      {
+        mode: 'single',
+        running_threads: raw[:running],
+        pool_capacity: raw[:pool_capacity],
+        max_threads: raw[:max_threads],
+        backlog: raw[:backed_up],
+        requests: raw[:requests_count],
+        raw: raw
+      }
+    else
+      { raw: raw }
+    end
+  rescue => e
+    { error: e.message }
+  end
+end

data/lib/debug_agent/inspectors/rails.rb

@@ -0,0 +1,127 @@
+module DebugAgent
+  register_tool('get_rails_routes',
+                'List all Rails routes: verb, path, controller#action ' \
+                '(requires Rails.application.routes)') do
+    unless defined?(::Rails) && defined?(::ActionDispatch)
+      return { error: 'Rails is not loaded (Rails::Application not found)' }
+    end
+
+    routes_set = ::Rails.application.routes.routes
+
+    routes = routes_set.map do |route|
+      {
+        name: route.name,
+        verb: route.verb.source.gsub(/[$^]/, ''),
+        path: route.path.spec.to_s,
+        controller: route.defaults[:controller]&.to_s,
+        action: route.defaults[:action]&.to_s,
+        internal: route.internal?
+      }
+    end
+
+    {
+      total: routes.size,
+      routes: routes
+    }
+  rescue => e
+    { error: e.message }
+  end
+
+  register_tool('get_rails_models',
+                'List ActiveRecord models: class name, table name, columns ' \
+                '(iterates ActiveRecord::Base.descendants)') do
+    unless defined?(::ActiveRecord)
+      return { error: 'ActiveRecord is not loaded (ActiveRecord::Base not found)' }
+    end
+
+    models = ::ActiveRecord::Base.descendants.map do |model|
+      columns =
+        begin
+          if model.table_exists?
+            model.columns.map do |col|
+              {
+                name: col.name,
+                type: col.sql_type_metadata&.type.to_s,
+                sql_type: col.sql_type_metadata&.sql_type.to_s,
+                null: col.null,
+                default: col.default,
+                primary: col.name == model.primary_key
+              }
+            end
+          else
+            []
+          end
+        rescue => e
+          [{ error: e.message }]
+        end
+
+      table_name = begin
+        model.table_name
+      rescue
+        nil
+      end
+
+      table_exists = begin
+        model.table_exists?
+      rescue
+        false
+      end
+
+      {
+        class_name: model.name,
+        table_name: table_name,
+        table_exists: table_exists,
+        column_count: columns.size,
+        columns: columns
+      }
+    end
+
+    {
+      total: models.size,
+      models: models.sort_by { |m| m[:class_name].to_s }
+    }
+  rescue => e
+    { error: e.message }
+  end
+
+  register_tool('get_rails_schema',
+                'Get ActiveRecord schema cache: table names and column definitions ' \
+                '(uses ActiveRecord::Base.connection.tables)') do
+    unless defined?(::ActiveRecord)
+      return { error: 'ActiveRecord is not loaded (ActiveRecord::Base not found)' }
+    end
+
+    connection = ::ActiveRecord::Base.connection
+    tables = connection.tables
+
+    schema = tables.map do |table|
+      columns =
+        begin
+          connection.columns(table).map do |col|
+            {
+              name: col.name,
+              type: col.sql_type_metadata&.type.to_s,
+              sql_type: col.sql_type_metadata&.sql_type.to_s,
+              null: col.null,
+              default: col.default
+            }
+          end
+        rescue => e
+          [{ error: e.message }]
+        end
+
+      {
+        table: table,
+        column_count: columns.size,
+        columns: columns
+      }
+    end
+
+    {
+      total_tables: schema.size,
+      tables: schema
+    }
+  rescue => e
+    { error: e.message }
+  end
+end

data/lib/debug_agent/inspectors/redis.rb

@@ -0,0 +1,205 @@
+module DebugAgent
+  # Registry for Redis clients (redis-rb). Applications register their
+  # Redis / connection-pool objects so the inspector can introspect them.
+  #
+  #   DebugAgent.register_redis_client(:cache, Redis.new(url: ENV['REDIS_URL']))
+  @redis_clients = {}
+
+  class << self
+    attr_reader :redis_clients
+
+    def register_redis_client(name, client)
+      @redis_clients[name.to_s] = client
+    end
+  end
+
+  # Resolve a registered Redis client. Accepts a bare Redis object or a
+  # ConnectionPool (redis-rb ships ConnectionPool support). We yield a
+  # usable connection object to the block.
+  def self.with_redis(name = nil)
+    name, client = if name
+      [name.to_s, redis_clients[name.to_s]]
+    else
+      redis_clients.first
+    end
+
+    return [nil, nil] unless client
+
+    [name, client]
+  end
+
+  register_tool('get_redis_pool_stats',
+                'Get Redis connection pool stats: registered clients, pool size, ' \
+                'available/in-use connections, host, port, db') do |name: nil|
+    return { error: 'Redis is not loaded (redis gem not installed)' } unless defined?(::Redis)
+    return { error: 'No Redis clients registered. Call DebugAgent.register_redis_client(:name, client).' } if redis_clients.empty?
+
+    targets = name ? { name.to_s => redis_clients[name.to_s] } : redis_clients
+    targets = targets.reject { |_, c| c.nil? }
+    return { error: "No Redis client registered under '#{name}'" } if targets.empty?
+
+    stats = targets.map do |client_name, client|
+      begin
+        info = {}
+
+        # ConnectionPool vs bare Redis
+        pool = nil
+        redis_conn = nil
+
+        if defined?(::ConnectionPool) && client.is_a?(::ConnectionPool)
+          pool = client
+          client.with { |c| redis_conn = c }
+        else
+          redis_conn = client
+        end
+
+        # Basic server connection details
+        info[:client_name] = client_name
+        info[:type] = pool ? 'connection_pool' : 'redis'
+
+        if redis_conn.respond_to?(:connection)
+          conn = redis_conn.connection rescue {}
+          info[:host] = conn[:host]
+          info[:port] = conn[:port]
+          info[:db]   = conn[:db]
+        end
+
+        if pool
+          # ConnectionPool does not expose live counters publicly; report
+          # configured size. Available/in-use are best-effort via instance vars.
+          info[:pool_configured_size] = pool.instance_variable_get(:@size)
+          info[:pool_available] = pool.instance_variable_get(:@available)&.length
+          info[:pool_in_use] = info[:pool_configured_size].to_i - info[:pool_available].to_i
+        else
+          info[:pool_configured_size] = 1
+          info[:pool_available] = 1
+          info[:pool_in_use] = 0
+        end
+
+        # Ping to confirm reachability
+        info[:connected] = begin
+          redis_conn.ping == 'PONG'
+        rescue => e
+          info[:ping_error] = e.message
+          false
+        end
+
+        info
+      rescue => e
+        { client_name: client_name, error: e.message }
+      end
+    end
+
+    { clients: stats }
+  rescue => e
+    { error: e.message }
+  end
+
+  register_tool('get_redis_info',
+                'Execute Redis INFO command and parse key sections ' \
+                '(Server, Clients, Memory, Stats, Keyspace)') do |name: nil|
+    return { error: 'Redis is not loaded (redis gem not installed)' } unless defined?(::Redis)
+
+    _name, client = DebugAgent.with_redis(name)
+    return { error: 'No Redis clients registered. Call DebugAgent.register_redis_client(:name, client).' } unless client
+
+    redis_conn =
+      if defined?(::ConnectionPool) && client.is_a?(::ConnectionPool)
+        client.with { |c| c }
+      else
+        client
+      end
+
+    raw = redis_conn.info
+    sections = {}
+
+    # Group known INFO keys into sections
+    section_keys = {
+      'Server'  => %w[redis_version redis_mode os arch_bits tcp_port uptime_in_seconds uptime_in_days],
+      'Clients' => %w[connected_clients blocked_clients tracking_clients],
+      'Memory'  => %w[used_memory used_memory_human used_memory_peak used_memory_peak_human used_memory_rss mem_fragmentation_ratio maxmemory maxmemory_human],
+      'Stats'   => %w[total_connections_received total_commands_processed instantaneous_ops_per_sec keyspace_hits keyspace_misses expired_keys evicted_keys pubsub_channels pubsub_patterns],
+      'Persistence' => %w[rdb_last_bgsave_status rdb_changes_since_last_save aof_enabled]
+    }
+
+    section_keys.each do |section, keys|
+      sections[section] = keys.each_with_object({}) do |k, h|
+        h[k] = raw[k] if raw.key?(k)
+      end
+    end
+
+    # Keyspace section looks like "db0:keys=10,expires=0,avg_ttl=0"
+    keyspace = {}
+    raw.each do |k, v|
+      next unless k =~ /^db\d+$/
+      parsed = v.split(',').each_with_object({}) do |pair, h|
+        key, val = pair.split('=')
+        h[key] = val
+      end
+      keyspace[k] = parsed
+    end
+    sections['Keyspace'] = keyspace unless keyspace.empty?
+
+    { sections: sections, raw_keys: raw.size }
+  rescue => e
+    { error: e.message }
+  end
+
+  register_tool('get_redis_latency',
+                'Measure Redis PING latency over 10 samples (min/avg/max in ms)') do |name: nil, samples: 10|
+    return { error: 'Redis is not loaded (redis gem not installed)' } unless defined?(::Redis)
+
+    _name, client = DebugAgent.with_redis(name)
+    return { error: 'No Redis clients registered. Call DebugAgent.register_redis_client(:name, client).' } unless client
+
+    samples = samples.to_i
+    samples = 10 if samples <= 0
+
+    redis_conn =
+      if defined?(::ConnectionPool) && client.is_a?(::ConnectionPool)
+        client.with { |c| c }
+      else
+        client
+      end
+
+    latencies = []
+    samples.times do
+      start = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      redis_conn.ping
+      finish = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      latencies << ((finish - start) * 1000.0)
+    end
+
+    {
+      samples: latencies.size,
+      min_ms: latencies.min.round(3),
+      avg_ms: (latencies.sum / latencies.size).round(3),
+      max_ms: latencies.max.round(3),
+      all_ms: latencies.map { |l| l.round(3) }
+    }
+  rescue => e
+    { error: e.message }
+  end
+
+  register_tool('get_redis_db_size',
+                'Execute Redis DBSIZE command (number of keys in current db)') do |name: nil|
+    return { error: 'Redis is not loaded (redis gem not installed)' } unless defined?(::Redis)
+
+    _name, client = DebugAgent.with_redis(name)
+    return { error: 'No Redis clients registered. Call DebugAgent.register_redis_client(:name, client).' } unless client
+
+    redis_conn =
+      if defined?(::ConnectionPool) && client.is_a?(::ConnectionPool)
+        client.with { |c| c }
+      else
+        client
+      end
+
+    {
+      db_size: redis_conn.dbsize,
+      client: _name
+    }
+  rescue => e
+    { error: e.message }
+  end
+end

data/lib/debug_agent/inspectors/sidekiq.rb

@@ -0,0 +1,121 @@
+module DebugAgent
+  # Registry for Sidekiq queue objects (Sidekiq::Queue instances). Applications
+  # register named queues so the inspector can read live stats.
+  #
+  #   DebugAgent.register_sidekiq_queue(:default, Sidekiq::Queue.new('default'))
+  @sidekiq_queues = {}
+
+  class << self
+    attr_reader :sidekiq_queues
+
+    def register_sidekiq_queue(name, queue)
+      @sidekiq_queues[name.to_s] = queue
+    end
+  end
+
+  register_tool('get_sidekiq_queues',
+                'Get Sidekiq queue stats: processed, failed, enqueued totals and ' \
+                'per-queue sizes (requires sidekiq)') do
+    unless defined?(::Sidekiq)
+      return { error: 'Sidekiq is not loaded (sidekiq gem not installed)' }
+    end
+
+    stats = ::Sidekiq::Stats.new
+
+    queues =
+      if sidekiq_queues.any?
+        sidekiq_queues.map do |name, queue|
+          {
+            name: name,
+            size: queue.size,
+            latency_seconds: queue.latency.to_f.round(3)
+          }
+        end
+      else
+        ::Sidekiq::Queue.all.map do |queue|
+          {
+            name: queue.name,
+            size: queue.size,
+            latency_seconds: queue.latency.to_f.round(3)
+          }
+        end
+      end
+
+    {
+      processed: stats.processed,
+      failed: stats.failed,
+      enqueued: stats.enqueued,
+      queues: queues
+    }
+  rescue => e
+    { error: e.message }
+  end
+
+  register_tool('get_sidekiq_workers',
+                'Get Sidekiq worker stats: busy workers, processes, total concurrency ' \
+                '(requires sidekiq)') do
+    unless defined?(::Sidekiq)
+      return { error: 'Sidekiq is not loaded (sidekiq gem not installed)' }
+    end
+
+    processes = ::Sidekiq::ProcessSet.new.to_a
+
+    total_busy = processes.sum(&:busy)
+    total_concurrency = processes.sum(&:concurrency)
+
+    process_list = processes.map do |p|
+      {
+        identity: p.identity,
+        hostname: p['hostname'],
+        pid: p['pid'],
+        started_at: p['started_at'],
+        concurrency: p.concurrency,
+        busy: p.busy,
+        queues: p['queues'] || []
+      }
+    end
+
+    {
+      busy: total_busy,
+      processes: process_list.size,
+      total_concurrency: total_concurrency,
+      process_list: process_list
+    }
+  rescue => e
+    { error: e.message }
+  end
+
+  register_tool('get_sidekiq_retries',
+                'Get Sidekiq retry set: count and sample jobs (requires sidekiq)') do |sample_size: 10|
+    unless defined?(::Sidekiq)
+      return { error: 'Sidekiq is not loaded (sidekiq gem not installed)' }
+    end
+
+    retry_set = ::Sidekiq::RetrySet.new
+    sample_size = sample_size.to_i
+    sample_size = 10 if sample_size <= 0
+
+    samples = []
+    retry_set.first(sample_size).each do |job|
+      samples << {
+        class: job.klass,
+        queue: job.queue,
+        args: job.args,
+        retry_count: job['retry_count'],
+        failed_at: job['failed_at'],
+        next_retry: job['next_at'] || job.at,
+        jid: job.jid,
+        error_message: job['error_message'],
+        error_class: job['error_class']
+      }
+    end
+
+    {
+      retry_count: retry_set.size,
+      sample_size: samples.size,
+      sample_jobs: samples
+    }
+  rescue => e
+    { error: e.message }
+  end
+end

data/lib/debug_agent/version.rb

@@ -1,3 +1,3 @@
 module DebugAgent
-  VERSION = '0.2.6'.freeze
+  VERSION = '0.3.0'.freeze
 end

data/lib/debug_agent.rb

@@ -18,6 +18,11 @@ require_relative 'debug_agent/inspectors/object_space'
 require_relative 'debug_agent/inspectors/threads'
 require_relative 'debug_agent/inspectors/routes'
 require_relative 'debug_agent/inspectors/process_info'
+require_relative 'debug_agent/inspectors/core_ext'
+require_relative 'debug_agent/inspectors/redis'
+require_relative 'debug_agent/inspectors/rails'
+require_relative 'debug_agent/inspectors/sidekiq'
+require_relative 'debug_agent/inspectors/puma'
 
 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.2.6
+  version: 0.3.0
 platform: ruby
 authors:
 - ggcode
@@ -51,8 +51,106 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: sinatra
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+- !ruby/object:Gem::Dependency
+  name: redis
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: connection_pool
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.4'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.4'
+- !ruby/object:Gem::Dependency
+  name: sidekiq
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '7.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '7.0'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: puma
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '6.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '6.0'
+- !ruby/object:Gem::Dependency
+  name: rackup
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
 description: Embed an AI debugging assistant into your Ruby web app. Inspect GC, threads,
-  memory, ObjectSpace, routes, HTTP requests, and more.
+  memory, ObjectSpace, routes, HTTP requests, Redis, Sidekiq, Puma, and more.
 email:
 - noreply@ggcode.dev
 executables: []
@@ -66,12 +164,17 @@ files:
 - lib/debug_agent/config.rb
 - lib/debug_agent/context_compressor.rb
 - lib/debug_agent/engine.rb
+- lib/debug_agent/inspectors/core_ext.rb
 - lib/debug_agent/inspectors/gc.rb
 - lib/debug_agent/inspectors/http_tracker.rb
 - lib/debug_agent/inspectors/object_space.rb
 - lib/debug_agent/inspectors/process_info.rb
+- lib/debug_agent/inspectors/puma.rb
+- lib/debug_agent/inspectors/rails.rb
+- lib/debug_agent/inspectors/redis.rb
 - lib/debug_agent/inspectors/routes.rb
 - lib/debug_agent/inspectors/runtime.rb
+- lib/debug_agent/inspectors/sidekiq.rb
 - lib/debug_agent/inspectors/system.rb
 - lib/debug_agent/inspectors/threads.rb
 - lib/debug_agent/llm_client.rb