debug-agent 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 94cb18c1904795fb713e2486d5f6d16e1bbce1a72d1820dd4122b2b7bc672a4d
-  data.tar.gz: 8cf474737f8b84aa5f2a20e5d07f13a02c7345df6805d6b075f72bbb5175fc4f
+  metadata.gz: 791b8f21395b061038d65dcae92007460556766622991c1c0a1692ae21b272f5
+  data.tar.gz: b57b2b97b9473da04c7b7fc3cf67729bddfc283e2ca71d34b4e6469d2c47e65a
 SHA512:
-  metadata.gz: 48c72eaf044cb325c3d8cb9e5ddc5afabbf85f5830e675795e8afb34182db5eb381f90ce913af411b4cf4acb662f82bf23373f2c12785e3dcee0a2491624e2a6
-  data.tar.gz: 20e31311478fd6e5a54e0f693ce5a3cddc27952e5816a56082050bf17e77e4b19aba10d74bde0e95689765ec9e851228c0921724bb566f7609848ab76a844d79
+  metadata.gz: 7fd90445975ede4bbc7474c7a57e94e1914098d9c4743180fdcdb737611ef461f2a6034da40fd31eb101188c34a28a12ac056db119f510e3de37ac494e06b67b
+  data.tar.gz: acf3c742b54b5d8173e6908ec27e079cd66efd4063f515b9278ec8754ef84e1539bbe5e13d47c79d342c33046678b972b9c6873cb6c5c9c96618669209145fa2

data/README.md

@@ -1,10 +1,10 @@
 # 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-40-blue)
-![Inspectors](https://img.shields.io/badge/inspectors-13-green)
+![Tools](https://img.shields.io/badge/tools-54-blue)
+![Inspectors](https://img.shields.io/badge/inspectors-20-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**.
+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**.
 
 ## Quick Start
 
@@ -55,10 +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
-- **40 diagnostic tools** across **13 inspectors**
+- **54 diagnostic tools** across **20 inspectors**
 - Zero external dependencies (no Datadog, no Grafana, no APM)
 
-## Inspectors & Tools (40)
+## Inspectors & Tools (54)
 
 ### GC Inspector
 | Tool | Description |
@@ -152,6 +152,47 @@ http://localhost:4567/agent
 | `get_signal_handlers` | List registered signal handlers (Signal.trap) |
 | `get_trap_handlers` | Inspect trap handlers for SIGINT, SIGTERM, etc. |
 
+### Logging Inspector
+| Tool | Description |
+|------|-------------|
+| `get_log_buffer` | Recent log entries from the built-in ring buffer |
+| `get_logger_info` | Current log level and configuration for registered loggers |
+| `set_log_level` | Dynamically set the log level for a registered logger |
+
+### Cache Inspector
+| Tool | Description |
+|------|-------------|
+| `get_cache_stats` | Stats for registered caches (hit rate, miss count, key count) |
+| `get_cache_keys` | List keys from a registered cache with optional prefix filter |
+| `clear_cache` | Clear all entries from a registered cache |
+
+### Outbound HTTP Inspector
+| Tool | Description |
+|------|-------------|
+| `get_http_connections` | HTTP client connection stats (Net::HTTP, connection pool) |
+| `get_outbound_summary` | Aggregated outbound HTTP call stats (total, avg latency, error rate) |
+
+### Metrics Inspector
+| Tool | Description |
+|------|-------------|
+| `get_registered_metrics` | List all registered Prometheus metrics |
+| `get_metric_value` | Get current value of a specific metric by name |
+
+### ActiveRecord Stats Inspector
+| Tool | Description |
+|------|-------------|
+| `get_active_record_query_stats` | ActiveRecord query statistics (queries per model, N+1 detection) |
+
+### Faraday Inspector
+| Tool | Description |
+|------|-------------|
+| `get_faraday_connections` | List Faraday connection objects with host, port, and adapter info |
+
+### Concurrent Inspector
+| Tool | Description |
+|------|-------------|
+| `get_concurrent_state` | Ruby concurrency primitives state (Mutex, ConditionVariable, Queue) |
+
 ## Custom Tools
 
 ```ruby

data/lib/debug_agent/inspectors/active_record_stats.rb

@@ -0,0 +1,131 @@
+require 'thread'
+
+module DebugAgent
+  # Track ActiveRecord SQL events (sql.active_record) to report query stats
+  # and N+1 detection hints. Auto-installs a subscriber when the tool is run.
+  @ar_stats = {
+    total_queries: 0,
+    total_time_ms: 0.0,
+    slow_queries: [],
+    query_counts: Hash.new(0),
+    query_times: Hash.new(0.0),
+    slow_threshold_ms: 100
+  }
+  @ar_lock = Mutex.new
+  @ar_tracker_installed = false
+
+  class << self
+    attr_reader :ar_stats
+
+    # Subscribe to sql.active_record notifications (idempotent).
+    def install_ar_tracker
+      return true if @ar_tracker_installed
+      return false unless defined?(::ActiveSupport::Notifications)
+
+      ::ActiveSupport::Notifications.subscribe('sql.active_record') do |_name, started, finished, _id, payload|
+        DebugAgent.record_ar_query(started, finished, payload)
+      end
+      @ar_tracker_installed = true
+      true
+    end
+
+    def record_ar_query(started, finished, payload)
+      duration_ms = ((finished - started) * 1000.0)
+      sql = payload[:sql].to_s.strip
+      return if sql.empty?
+
+      fp = ar_fingerprint(sql)
+      name = payload[:name]
+
+      @ar_lock.synchronize do
+        s = @ar_stats
+        s[:total_queries] += 1
+        s[:total_time_ms] += duration_ms
+        next unless fp
+        s[:query_counts][fp] += 1
+        s[:query_times][fp] += duration_ms
+        if duration_ms >= s[:slow_threshold_ms] && s[:slow_queries].size < 200
+          s[:slow_queries] << {
+            sql: sql[0..500],
+            name: name,
+            duration_ms: duration_ms.round(2),
+            timestamp: finished.to_s
+          }
+        end
+      end
+    rescue
+      nil
+    end
+
+    # Normalize SQL into a fingerprint for grouping / N+1 detection.
+    def ar_fingerprint(sql)
+      sql
+        .gsub(/'[^']*'/, '?')
+        .gsub(/\b\d+\b/, '?')
+        .gsub(/\s+/, ' ')
+        .strip[0..200]
+    end
+  end
+
+  register_tool('get_active_record_query_stats',
+                'Query statistics from ActiveRecord: total queries, avg query time, ' \
+                'slow queries, and N+1 detection hints (subscribes to sql.active_record)') do
+    next { error: 'ActiveRecord is not loaded (activerecord gem not installed)' } unless defined?(::ActiveRecord)
+
+    install_ar_tracker
+
+    snapshot = @ar_lock.synchronize do
+      {
+        total_queries: @ar_stats[:total_queries],
+        total_time_ms: @ar_stats[:total_time_ms].round(2),
+        slow_queries: @ar_stats[:slow_queries].dup,
+        query_counts: @ar_stats[:query_counts].dup,
+        query_times: @ar_stats[:query_times].dup,
+        slow_threshold_ms: @ar_stats[:slow_threshold_ms]
+      }
+    end
+
+    total = snapshot[:total_queries]
+    avg = total.zero? ? 0.0 : (snapshot[:total_time_ms] / total)
+
+    # N+1 suspects: the same query fingerprint executed many times.
+    n_plus_suspects =
+      snapshot[:query_counts]
+        .select { |_, count| count >= 5 }
+        .sort_by { |_, count| -count }
+        .first(10)
+        .map do |fp, count|
+          time = snapshot[:query_times][fp]
+          {
+            fingerprint: fp,
+            count: count,
+            total_time_ms: time.round(2),
+            avg_time_ms: (time / count).round(2)
+          }
+        end
+
+    result = {
+      tracker_active: @ar_tracker_installed,
+      total_queries: total,
+      total_query_time_ms: snapshot[:total_time_ms],
+      avg_query_time_ms: avg.round(2),
+      slow_query_threshold_ms: snapshot[:slow_threshold_ms],
+      slow_query_count: snapshot[:slow_queries].size,
+      slow_queries: snapshot[:slow_queries].last(20).reverse,
+      n_plus_suspects: n_plus_suspects
+    }
+
+    # Best-effort: include query cache info if available.
+    if ::ActiveRecord::Base.connection.respond_to?(:query_cache)
+      begin
+        result[:query_cache_enabled] = ::ActiveRecord::Base.connection.query_cache_enabled
+      rescue
+        nil
+      end
+    end
+
+    result
+  rescue => e
+    { error: e.message }
+  end
+end

data/lib/debug_agent/inspectors/cache.rb

@@ -0,0 +1,194 @@
+module DebugAgent
+  # Registry of named cache objects. Applications register caches so the
+  # inspector can introspect stats, keys, and clear them.
+  #
+  #   DebugAgent.register_cache(:rails, Rails.cache)
+  @caches = {}
+
+  class << self
+    attr_reader :caches
+
+    def register_cache(name, cache)
+      @caches[name.to_s] = cache
+    end
+
+    # Introspect a cache object, supporting ActiveSupport::Cache::MemoryStore,
+    # generic ActiveSupport::Cache::Store, plain Hashes, and custom caches.
+    def cache_stats_for(cache)
+      if defined?(::ActiveSupport::Cache::MemoryStore) && cache.is_a?(::ActiveSupport::Cache::MemoryStore)
+        data = cache.instance_variable_get(:@data) || {}
+        key_access = cache.instance_variable_get(:@key_access) || {}
+        {
+          type: 'ActiveSupport::Cache::MemoryStore',
+          size: data.size,
+          max_size: cache.instance_variable_get(:@max_size),
+          tracked_keys: key_access.size,
+          sample_keys: data.keys.first(50)
+        }
+      elsif defined?(::ActiveSupport::Cache::Store) && defined?(::ActiveSupport::Cache) &&
+            cache.is_a?(::ActiveSupport::Cache::Store)
+        stats = best_effort_cache_stats(cache)
+        stats.merge(type: cache.class.name)
+      elsif cache.is_a?(Hash)
+        {
+          type: 'Hash',
+          size: cache.size,
+          sample_keys: cache.keys.first(50)
+        }
+      else
+        stats = best_effort_cache_stats(cache)
+        stats.merge(type: cache.class.name)
+      end
+    end
+
+    # Extract hit/miss and size where the cache exposes them (e.g. Dalli).
+    def best_effort_cache_stats(cache)
+      result = {}
+      result[:size] = cache_size_for(cache)
+
+      if cache.respond_to?(:stats)
+        raw =
+          begin
+            cache.stats
+          rescue
+            {}
+          end
+        if raw.is_a?(Hash)
+          result[:raw_stats] = raw
+          hits = raw['get_hits'] || raw[:get_hits]
+          misses = raw['get_misses'] || raw[:get_misses]
+          if hits && misses
+            total = hits.to_i + misses.to_i
+            result[:hits] = hits.to_i
+            result[:misses] = misses.to_i
+            result[:hit_rate] = total.zero? ? nil : format('%.1f%%', hits.to_f / total * 100)
+          end
+        end
+      end
+      result
+    end
+
+    def cache_keys_for(cache)
+      if defined?(::ActiveSupport::Cache::MemoryStore) && cache.is_a?(::ActiveSupport::Cache::MemoryStore)
+        (cache.instance_variable_get(:@data) || {}).keys
+      elsif cache.is_a?(Hash)
+        cache.keys
+      elsif cache.respond_to?(:keys)
+        begin
+          cache.keys
+        rescue
+          []
+        end
+      else
+        []
+      end
+    end
+
+    def cache_size_for(cache)
+      if defined?(::ActiveSupport::Cache::MemoryStore) && cache.is_a?(::ActiveSupport::Cache::MemoryStore)
+        (cache.instance_variable_get(:@data) || {}).size
+      elsif cache.respond_to?(:size)
+        begin
+          cache.size
+        rescue
+          nil
+        end
+      elsif cache.respond_to?(:length)
+        begin
+          cache.length
+        rescue
+          nil
+        end
+      end
+    end
+  end
+
+  register_tool('get_cache_stats',
+                'Get stats for registered caches: hit/miss ratio, size, entries. ' \
+                'Supports Rails.cache, ActiveSupport::Cache::MemoryStore, and Hash caches') do |name: nil|
+    if caches.empty?
+      next { error: 'No caches registered. Call DebugAgent.register_cache(:name, cache).' }
+    end
+
+    targets = name ? { name.to_s => caches[name.to_s] } : caches
+    targets = targets.reject { |_, c| c.nil? }
+    next { error: "No cache registered under '#{name}'" } if targets.empty?
+
+    results = targets.map do |cache_name, cache|
+      begin
+        cache_stats_for(cache).merge(name: cache_name)
+      rescue => e
+        { name: cache_name, error: e.message }
+      end
+    end
+
+    { caches: results }
+  rescue => e
+    { error: e.message }
+  end
+
+  register_tool('get_cache_keys',
+                'List keys in a registered cache with optional prefix filter',
+                name: { type: 'string', description: 'Registered cache name (optional, defaults to first)', required: false },
+                prefix: { type: 'string', description: 'Only return keys starting with this prefix', required: false }) do |name: nil, prefix: nil|
+    if caches.empty?
+      next { error: 'No caches registered. Call DebugAgent.register_cache(:name, cache).' }
+    end
+
+    cache_name, cache = name ? [name.to_s, caches[name.to_s]] : caches.first
+    next { error: "No cache registered under '#{name}'" } unless cache
+
+    keys = cache_keys_for(cache)
+    if prefix && !prefix.to_s.empty?
+      keys = keys.select { |k| k.to_s.start_with?(prefix.to_s) }
+    end
+
+    {
+      cache: cache_name,
+      total_keys: keys.size,
+      keys: keys.first(500)
+    }
+  rescue => e
+    { error: e.message }
+  end
+
+  register_tool('clear_cache',
+                'Clear a registered cache (destructive: removes all entries)',
+                name: { type: 'string', description: 'Registered cache name (optional, defaults to first)', required: false }) do |name: nil|
+    if caches.empty?
+      next { error: 'No caches registered. Call DebugAgent.register_cache(:name, cache).' }
+    end
+
+    cache_name, cache = name ? [name.to_s, caches[name.to_s]] : caches.first
+    next { error: "No cache registered under '#{name}'" } unless cache
+
+    before = cache_size_for(cache)
+
+    cleared =
+      if cache.respond_to?(:clear)
+        cache.clear
+        true
+      elsif cache.is_a?(Hash)
+        cache.clear
+        true
+      elsif cache.respond_to?(:clear_all)
+        cache.clear_all
+        true
+      elsif cache.respond_to?(:delete_all)
+        cache.delete_all
+        true
+      elsif cache.respond_to?(:flushdb)
+        cache.flushdb
+        true
+      else
+        false
+      end
+
+    next { error: "Cache '#{cache_name}' (#{cache.class}) does not support clearing" } unless cleared
+
+    after = cache_size_for(cache)
+    { cache: cache_name, cleared: true, size_before: before, size_after: after }
+  rescue => e
+    { error: e.message }
+  end
+end

data/lib/debug_agent/inspectors/concurrent.rb

@@ -0,0 +1,78 @@
+module DebugAgent
+  # Inspector for the concurrent-ruby gem: global executor pools and any
+  # registered promises/futures.
+  #
+  #   DebugAgent.register_concurrent(:my_task, Concurrent::Promises.future { ... })
+  @concurrent_promises = {}
+
+  class << self
+    attr_reader :concurrent_promises
+
+    def register_concurrent(name, promise)
+      @concurrent_promises[name.to_s] = promise
+    end
+
+    def executor_info(executor)
+      return nil unless executor
+      info = { class: executor.class.name }
+      %i[running?].each do |m|
+        info[m] = executor.public_send(m) if executor.respond_to?(m)
+      end
+      %i[length largest_length queue_length scheduled_task_count completed_task_count
+         max_threads min_threads idletime max_queue].each do |m|
+        info[m] = (executor.public_send(m) rescue nil) if executor.respond_to?(m)
+      end
+      info
+    rescue => e
+      { class: executor&.class&.name, error: e.message }
+    end
+
+    def promise_info(name, promise)
+      info = { name: name, class: promise.class.name }
+      info[:state] = promise.state if promise.respond_to?(:state)
+      if promise.respond_to?(:fulfilled?)
+        info[:fulfilled] = promise.fulfilled?
+        info[:rejected] = promise.rejected? if promise.respond_to?(:rejected?)
+        info[:pending] = promise.pending? if promise.respond_to?(:pending?)
+      end
+      if promise.respond_to?(:reason)
+        reason = promise.reason
+        info[:reason] = reason.is_a?(Exception) ? reason.message : reason.inspect unless reason.nil?
+      end
+      info
+    rescue => e
+      { name: name, error: e.message }
+    end
+  end
+
+  register_tool('get_concurrent_state',
+                'If concurrent-ruby is loaded, list global executor pools and registered ' \
+                'promises/futures with their state') do
+    next { error: 'concurrent-ruby is not loaded (concurrent-ruby gem not installed)' } unless defined?(::Concurrent)
+
+    executors = {}
+    if ::Concurrent.respond_to?(:global_io_executor)
+      executors[:global_io] = executor_info(::Concurrent.global_io_executor)
+    end
+    if ::Concurrent.respond_to?(:global_fast_executor)
+      executors[:global_fast] = executor_info(::Concurrent.global_fast_executor)
+    end
+    if ::Concurrent.respond_to?(:global_immediate_executor)
+      executors[:global_immediate] = executor_info(::Concurrent.global_immediate_executor)
+    end
+
+    promises =
+      if concurrent_promises.empty?
+        { message: 'No promises/futures registered. Call DebugAgent.register_concurrent(:name, future).' }
+      else
+        concurrent_promises.map { |n, p| promise_info(n, p) }
+      end
+
+    {
+      executors: executors,
+      registered_promises: promises
+    }
+  rescue => e
+    { error: e.message }
+  end
+end

data/lib/debug_agent/inspectors/faraday.rb

@@ -0,0 +1,79 @@
+module DebugAgent
+  # Registry of named Faraday connections so the inspector can introspect them.
+  #
+  #   DebugAgent.register_faraday(:api, Faraday.new('https://api.example.com'))
+  @faraday_connections = {}
+
+  class << self
+    attr_reader :faraday_connections
+
+    def register_faraday(name, conn)
+      @faraday_connections[name.to_s] = conn
+    end
+
+    def faraday_conn_info(name, conn)
+      info = { name: name, class: conn.class.name }
+
+      if conn.respond_to?(:url_prefix)
+        info[:url] = conn.url_prefix.to_s
+        info[:host] = conn.url_prefix.host
+        info[:port] = conn.url_prefix.port
+        info[:scheme] = conn.url_prefix.scheme
+      end
+
+      builder = conn.respond_to?(:builder) ? conn.builder : nil
+      if builder
+        handlers =
+          if builder.respond_to?(:handlers)
+            builder.handlers.map { |h| faraday_handler_name(h) }
+          else
+            []
+          end
+        info[:middleware] = handlers
+
+        adapter =
+          if builder.respond_to?(:adapter)
+            faraday_handler_name(builder.adapter)
+          end
+        info[:adapter] = adapter if adapter
+      end
+
+      info[:headers] = conn.headers.to_h if conn.respond_to?(:headers) && conn.headers.respond_to?(:to_h)
+
+      info
+    rescue => e
+      { name: name, error: e.message }
+    end
+
+    def faraday_handler_name(handler)
+      return handler.name if handler.respond_to?(:name)
+      return handler.class.name if handler.respond_to?(:class)
+      handler.to_s
+    end
+  end
+
+  register_tool('get_faraday_connections',
+                'List registered Faraday connections with URL, adapter, and middleware stack ' \
+                '(requires faraday gem)') do |name: nil|
+    next { error: 'Faraday is not loaded (faraday gem not installed)' } unless defined?(::Faraday)
+
+    conns = faraday_connections
+    if conns.empty?
+      next {
+        message: 'No Faraday connections registered. Call DebugAgent.register_faraday(:name, conn).'
+      }
+    end
+
+    targets = name ? { name.to_s => conns[name.to_s] } : conns
+    targets = targets.reject { |_, c| c.nil? }
+    next { error: "No Faraday connection registered under '#{name}'" } if targets.empty?
+
+    list = targets.map do |conn_name, conn|
+      faraday_conn_info(conn_name, conn)
+    end
+
+    { connections: list }
+  rescue => e
+    { error: e.message }
+  end
+end

data/lib/debug_agent/inspectors/gc.rb

@@ -62,6 +62,59 @@ module DebugAgent
     { error: e.message }
   end
 
+  register_tool('get_gc_profiler_detail',
+                'Get GC::Profiler raw data with computed stats: total time, count, ' \
+                'min/avg/max GC time, total mark and sweep time, per-GC entries') do
+    unless defined?(GC::Profiler)
+      next { enabled: false, message: 'GC::Profiler is not available on this Ruby implementation' }
+    end
+
+    raw_data = GC::Profiler.raw_data
+    total_time = GC::Profiler.total_time
+
+    if raw_data.nil? || raw_data.empty?
+      next {
+        enabled: true,
+        total_gc_time_seconds: 0,
+        gc_count: 0,
+        message: 'GC::Profiler has no data. Call GC::Profiler.enable to start collecting.'
+      }
+    end
+
+    gc_times = raw_data.map { |e| e[:GC_TIME].to_f }
+    mark_times = raw_data.map { |e| e[:GC_MARK_TIME].to_f }
+    sweep_times = raw_data.map { |e| e[:GC_SWEEP_TIME].to_f }
+    avg = gc_times.sum / gc_times.size
+
+    {
+      enabled: true,
+      total_gc_time_seconds: total_time.round(6),
+      gc_count: raw_data.size,
+      gc_time_stats_ms: {
+        min: (gc_times.min * 1000).round(3),
+        avg: (avg * 1000).round(3),
+        max: (gc_times.max * 1000).round(3)
+      },
+      total_mark_time_seconds: mark_times.sum.round(6),
+      total_sweep_time_seconds: sweep_times.sum.round(6),
+      entries: raw_data.map.with_index do |entry, i|
+        {
+          index: i,
+          gc_time_ms: (entry[:GC_TIME].to_f * 1000).round(3),
+          gc_invoke_time: entry[:GC_INVOKE_TIME]&.round(6),
+          heap_use_pages: entry[:HEAP_USE_PAGES],
+          heap_live_objects: entry[:HEAP_LIVE_OBJECTS],
+          heap_free_objects: entry[:HEAP_FREE_OBJECTS],
+          heap_total_objects: entry[:HEAP_TOTAL_OBJECTS],
+          gc_mark_time_ms: (entry[:GC_MARK_TIME].to_f * 1000).round(3),
+          gc_sweep_time_ms: (entry[:GC_SWEEP_TIME].to_f * 1000).round(3)
+        }
+      end
+    }
+  rescue => e
+    { error: e.message }
+  end
+
   register_tool('force_gc',
                 'Trigger a full garbage collection (GC.start with full_mark) and show before/after comparison') do
     before_stats = GC.stat

data/lib/debug_agent/inspectors/http_client.rb

@@ -0,0 +1,145 @@
+require 'time'
+require 'thread'
+
+module DebugAgent
+  # Track outbound Net::HTTP calls (latency, errors, hosts) and live
+  # connections by wrapping Net::HTTP#request, #start and #finish.
+  @outbound_stats = { total: 0, latencies: [], errors: 0, hosts: {} }
+  @outbound_lock = Mutex.new
+  @http_connections = {}
+
+  class << self
+    attr_reader :outbound_stats
+
+    def record_outbound(http, req, latency_ms, error)
+      @outbound_lock.synchronize do
+        s = @outbound_stats
+        s[:total] += 1
+        s[:latencies] << latency_ms
+        s[:latencies].shift if s[:latencies].size > 1000
+
+        host_key = "#{http.address}:#{http.port}"
+        h = (s[:hosts][host_key] ||= { count: 0, latencies: [], errors: 0 })
+        h[:count] += 1
+        h[:latencies] << latency_ms
+        h[:latencies].shift if h[:latencies].size > 200
+        if error
+          s[:errors] += 1
+          h[:errors] += 1
+        end
+      end
+    end
+
+    def track_http_connect(http)
+      @outbound_lock.synchronize do
+        @http_connections[http.object_id] = {
+          host: http.address,
+          port: http.port,
+          use_ssl: http.use_ssl?,
+          started_at: Time.now.iso8601,
+          active: true
+        }
+      end
+    end
+
+    def track_http_disconnect(http)
+      @outbound_lock.synchronize do
+        conn = @http_connections[http.object_id]
+        conn[:active] = false if conn
+      end
+    end
+
+    # Wrap Net::HTTP once to capture outbound request metrics.
+    def install_outbound_tracker
+      return false unless defined?(::Net::HTTP)
+      return true if ::Net::HTTP.include?(OutboundHttpTracker)
+
+      ::Net::HTTP.prepend(OutboundHttpTracker)
+      true
+    end
+  end
+
+  # Prepended module that instruments Net::HTTP request lifecycle.
+  module OutboundHttpTracker
+    def start
+      DebugAgent.track_http_connect(self) rescue nil
+      super
+    end
+
+    def finish
+      DebugAgent.track_http_disconnect(self) rescue nil
+      super
+    end
+
+    def request(req, *args, &block)
+      started = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      begin
+        result = super
+        elapsed = ((Process.clock_gettime(Process::CLOCK_MONOTONIC) - started) * 1000.0)
+        DebugAgent.record_outbound(self, req, elapsed, nil) rescue nil
+        result
+      rescue => e
+        elapsed = ((Process.clock_gettime(Process::CLOCK_MONOTONIC) - started) * 1000.0)
+        DebugAgent.record_outbound(self, req, elapsed, e) rescue nil
+        raise
+      end
+    end
+  end
+
+  # Auto-install the tracker at load time when Net::HTTP is available.
+  install_outbound_tracker
+
+  register_tool('get_http_connections',
+                'List Net::HTTP connections and their state: host, port, use_ssl, ' \
+                'start_time, active connections') do
+    conns = @outbound_lock.synchronize { @http_connections.values }
+    active = conns.select { |c| c[:active] }
+    {
+      active_count: active.size,
+      total_tracked: conns.size,
+      tracker_active: defined?(::Net::HTTP) && ::Net::HTTP.include?(OutboundHttpTracker),
+      connections: conns.last(200)
+    }
+  rescue => e
+    { error: e.message }
+  end
+
+  register_tool('get_outbound_summary',
+                'Summary of outbound HTTP calls tracked by the agent: total, avg latency, ' \
+                'error rate, top hosts') do
+    snapshot = @outbound_lock.synchronize do
+      {
+        total: @outbound_stats[:total],
+        latencies: @outbound_stats[:latencies].dup,
+        errors: @outbound_stats[:errors],
+        hosts: @outbound_stats[:hosts].transform_values(&:dup)
+      }
+    end
+
+    lats = snapshot[:latencies]
+    avg = lats.empty? ? 0.0 : (lats.sum / lats.size)
+    total = snapshot[:total]
+
+    top_hosts = snapshot[:hosts].map do |host, info|
+      hl = info[:latencies]
+      {
+        host: host,
+        count: info[:count],
+        avg_latency_ms: hl.empty? ? 0 : (hl.sum / hl.size).round(2),
+        errors: info[:errors]
+      }
+    end.sort_by { |h| -h[:count] }.first(10)
+
+    {
+      total_requests: total,
+      avg_latency_ms: avg.round(2),
+      error_count: snapshot[:errors],
+      error_rate: total.zero? ? '0.0%' : format('%.1f%%', snapshot[:errors].to_f / total * 100),
+      tracked_hosts: snapshot[:hosts].size,
+      tracker_active: defined?(::Net::HTTP) && ::Net::HTTP.include?(OutboundHttpTracker),
+      top_hosts: top_hosts
+    }
+  rescue => e
+    { error: e.message }
+  end
+end

data/lib/debug_agent/inspectors/logging.rb

@@ -0,0 +1,163 @@
+require 'time'
+require 'thread'
+require 'logger'
+
+module DebugAgent
+  # Ring buffer of recent log entries and a registry of named loggers.
+  #
+  #   DebugAgent.register_logger(:app, Rails.logger)
+  MAX_LOGS = 100
+
+  @log_buffer = []
+  @log_buffer_lock = Mutex.new
+  @loggers = {}
+
+  class << self
+    attr_reader :loggers
+
+    def register_logger(name, logger)
+      @loggers[name.to_s] = logger
+    end
+
+    # Invoked by the wrapped Logger#add to push an entry into the ring buffer.
+    def capture_log(severity, args)
+      args = args.is_a?(Array) ? args : [args]
+      # Logger passes (message, progname); pick the meaningful value.
+      msg = args.compact.first
+      entry = {
+        timestamp: Time.now.iso8601,
+        severity: severity_label(severity),
+        message: msg.respond_to?(:to_str) ? msg.to_s : msg.inspect
+      }
+      @log_buffer_lock.synchronize do
+        @log_buffer << entry
+        @log_buffer.shift if @log_buffer.size > MAX_LOGS
+      end
+    end
+
+    # Wrap the standard Logger#add / << so all log output flows into the ring
+    # buffer. Only wraps once — guarded by checking for the aliased method.
+    def install_log_capture
+      return false unless defined?(::Logger)
+      return true if ::Logger.method_defined?(:_original_add)
+
+      ::Logger.class_eval do
+        alias_method :_original_add, :add
+        alias_method :_original_lshift, :<<
+
+        def add(severity, *args, &block)
+          if block
+            msg = args[0]
+            msg = block.call if msg.nil?
+            DebugAgent.capture_log(severity, [msg]) rescue nil
+            _original_add(severity, msg, *args[1..-1])
+          else
+            DebugAgent.capture_log(severity, args) rescue nil
+            _original_add(severity, *args)
+          end
+        end
+
+        def <<(msg)
+          DebugAgent.capture_log(nil, [msg]) rescue nil
+          _original_lshift(msg)
+        end
+      end
+      true
+    end
+
+    # Map a Logger severity integer to a human-readable label.
+    def severity_label(severity)
+      labels = %w[DEBUG INFO WARN ERROR FATAL ANY]
+      idx = severity.is_a?(Integer) ? severity : (defined?(::Logger) ? ::Logger::UNKNOWN : 5)
+      labels[idx] || 'UNKNOWN'
+    end
+  end
+
+  # Attempt to wrap Logger at load time (no-op if Logger isn't loaded yet).
+  install_log_capture
+
+  LEVEL_MAP = {
+    'debug' => defined?(::Logger) ? ::Logger::DEBUG : 0,
+    'info'  => defined?(::Logger) ? ::Logger::INFO  : 1,
+    'warn'  => defined?(::Logger) ? ::Logger::WARN  : 2,
+    'error' => defined?(::Logger) ? ::Logger::ERROR : 3,
+    'fatal' => defined?(::Logger) ? ::Logger::FATAL : 4
+  }.freeze
+
+  register_tool('get_log_buffer',
+                'Return recent log entries captured from the built-in ring buffer ' \
+                '(Logger#add and << are auto-wrapped)') do |limit: 50|
+    limit = limit.to_i
+    limit = 50 if limit <= 0
+    entries = @log_buffer_lock.synchronize { @log_buffer.dup }
+    {
+      total_captured: entries.size,
+      capacity: MAX_LOGS,
+      capture_active: defined?(::Logger) && ::Logger.method_defined?(:_original_add),
+      entries: entries.last(limit).reverse
+    }
+  rescue => e
+    { error: e.message }
+  end
+
+  register_tool('get_logger_info',
+                'List registered loggers with configuration: level, device, formatter, progname') do
+    if loggers.empty?
+      next {
+        message: 'No loggers registered. Call DebugAgent.register_logger(:name, logger).',
+        capture_active: defined?(::Logger) && ::Logger.method_defined?(:_original_add)
+      }
+    end
+
+    list = loggers.map do |name, logger|
+      info = { name: name, class: logger.class.name }
+      info[:level] = severity_label(logger.level) if logger.respond_to?(:level)
+      info[:progname] = logger.progname if logger.respond_to?(:progname)
+
+      if defined?(::Logger) && logger.is_a?(::Logger)
+        logdev = logger.instance_variable_get(:@logdev)
+        dev = logdev&.instance_variable_get(:@dev)
+        info[:device] =
+          case dev
+          when IO then dev.inspect
+          when String then dev
+          when nil then nil
+          else dev.inspect
+          end
+        formatter = logger.instance_variable_get(:@formatter)
+        info[:formatter] = formatter ? formatter.class.name : 'default'
+      end
+      info
+    rescue => e
+      { name: name, error: e.message }
+    end
+
+    { loggers: list }
+  rescue => e
+    { error: e.message }
+  end
+
+  register_tool('set_log_level',
+                "Dynamically change a registered logger's level",
+                logger_name: { type: 'string', description: 'Registered logger name' },
+                level: { type: 'string', description: 'One of: debug, info, warn, error, fatal' }) do |logger_name:, level:|
+    logger = loggers[logger_name.to_s]
+    next({ error: "No logger registered under '#{logger_name}'" }) unless logger
+    next({ error: 'Logger does not respond to level=' }) unless logger.respond_to?(:level=)
+
+    target = LEVEL_MAP[level.to_s.downcase]
+    next({ error: "Invalid level '#{level}'. Use debug/info/warn/error/fatal." }) unless target
+
+    previous = severity_label(logger.level)
+    logger.level = target
+
+    {
+      logger: logger_name,
+      previous_level: previous,
+      new_level: level.to_s.downcase,
+      success: true
+    }
+  rescue => e
+    { error: e.message }
+  end
+end

data/lib/debug_agent/inspectors/metrics.rb

@@ -0,0 +1,71 @@
+module DebugAgent
+  # Inspector for Prometheus metrics (prometheus-client gem).
+  # Uses the default registry: Prometheus::Client.registry.
+
+  class << self
+    # Resolve the Prometheus registry to inspect.
+    def prometheus_registry
+      return nil unless defined?(::Prometheus) && defined?(::Prometheus::Client)
+      ::Prometheus::Client.respond_to?(:registry) ? ::Prometheus::Client.registry : nil
+    end
+
+    # Safely read a metric's value(s). Different metric types return
+    # different shapes from #get.
+    def prometheus_metric_value(metric)
+      begin
+        value = metric.get({})
+        # Counter/Gauge return a Hash of {labels => value}; unwrap the unlabeled value.
+        if value.is_a?(Hash) && value.size == 1 && value.key?({})
+          value[{}]
+        else
+          value
+        end
+      rescue => e
+        { error: e.message }
+      end
+    end
+  end
+
+  register_tool('get_registered_metrics',
+                'List registered Prometheus metrics from the prometheus-client gem: ' \
+                'name, type, docstring, value') do
+    registry = prometheus_registry
+    next { error: 'Prometheus client is not loaded (prometheus-client gem not installed)' } unless registry
+    next { error: 'No Prometheus registry available' } unless registry.respond_to?(:metrics)
+
+    metrics = registry.metrics.map do |metric|
+      {
+        name: metric.name,
+        type: metric.respond_to?(:type) ? metric.type.to_s : 'unknown',
+        docstring: metric.respond_to?(:docstring) ? metric.docstring : nil,
+        value: prometheus_metric_value(metric)
+      }
+    rescue => e
+      { name: metric&.respond_to?(:name) ? metric.name : 'unknown', error: e.message }
+    end
+
+    { total: metrics.size, metrics: metrics }
+  rescue => e
+    { error: e.message }
+  end
+
+  register_tool('get_metric_value',
+                'Get a specific Prometheus metric value by name',
+                name: { type: 'string', description: 'Registered metric name' }) do |name:|
+    registry = prometheus_registry
+    next { error: 'Prometheus client is not loaded (prometheus-client gem not installed)' } unless registry
+    next { error: 'No Prometheus registry available' } unless registry.respond_to?(:metrics)
+
+    metric = registry.metrics.find { |m| m.respond_to?(:name) && m.name.to_s == name.to_s }
+    next { error: "Metric '#{name}' not found in registry" } unless metric
+
+    {
+      name: metric.name,
+      type: metric.respond_to?(:type) ? metric.type.to_s : 'unknown',
+      docstring: metric.respond_to?(:docstring) ? metric.docstring : nil,
+      value: prometheus_metric_value(metric)
+    }
+  rescue => e
+    { error: e.message }
+  end
+end

data/lib/debug_agent/version.rb

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

data/lib/debug_agent.rb

@@ -23,6 +23,13 @@ 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.3.0
+  version: 0.4.0
 platform: ruby
 authors:
 - ggcode
@@ -164,9 +164,16 @@ 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