debug-agent 0.2.6 → 0.4.0

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.4.0'.freeze
 end

data/lib/debug_agent.rb

@@ -18,6 +18,18 @@ 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'
+require_relative 'debug_agent/inspectors/logging'
+require_relative 'debug_agent/inspectors/cache'
+require_relative 'debug_agent/inspectors/http_client'
+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'
 
 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.4.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,24 @@ files:
 - lib/debug_agent/config.rb
 - lib/debug_agent/context_compressor.rb
 - lib/debug_agent/engine.rb
+- lib/debug_agent/inspectors/active_record_stats.rb
+- lib/debug_agent/inspectors/cache.rb
+- lib/debug_agent/inspectors/concurrent.rb
+- lib/debug_agent/inspectors/core_ext.rb
+- lib/debug_agent/inspectors/faraday.rb
 - lib/debug_agent/inspectors/gc.rb
+- lib/debug_agent/inspectors/http_client.rb
 - lib/debug_agent/inspectors/http_tracker.rb
+- lib/debug_agent/inspectors/logging.rb
+- lib/debug_agent/inspectors/metrics.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