debug-agent 0.2.6 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 282c047d0e86a70412110ecbd1a3579ee8a71af4b2743de37a4769242df6b634
-  data.tar.gz: ba97cf4ae8a5757f70c5bf261e5b5b34fb5d752a5543e9b4c657db5fdfc299bf
+  metadata.gz: 791b8f21395b061038d65dcae92007460556766622991c1c0a1692ae21b272f5
+  data.tar.gz: b57b2b97b9473da04c7b7fc3cf67729bddfc283e2ca71d34b4e6469d2c47e65a
 SHA512:
-  metadata.gz: 0b68399b6dd5fe9d83f9369a9ab896bde2c2d6941a3d8d531b6721427f21b96643e9e8b3793a7da31984b34da7ed79779ba43a30bcbf57e6c20b8451831482f0
-  data.tar.gz: c4dc62c89f4bfd0100dae01b636130cc0316b5bc1f2981db85d52a8e360a997bf755851187719be8a88f4e05faf443bbc7c535d83b29011ba4c4b2fd8582cb89
+  metadata.gz: 7fd90445975ede4bbc7474c7a57e94e1914098d9c4743180fdcdb737611ef461f2a6034da40fd31eb101188c34a28a12ac056db119f510e3de37ac494e06b67b
+  data.tar.gz: acf3c742b54b5d8173e6908ec27e079cd66efd4063f515b9278ec8754ef84e1539bbe5e13d47c79d342c33046678b972b9c6873cb6c5c9c96618669209145fa2

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-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 — **54 diagnostic tools across 20 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
+- **54 diagnostic tools** across **20 inspectors**
+- Zero external dependencies (no Datadog, no Grafana, no APM)
 
-## Inspectors & Tools (26)
+## Inspectors & Tools (54)
 
 ### 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,84 @@ 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. |
+
+### 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
@@ -133,12 +215,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/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/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