debug-agent 0.3.0 → 0.5.0

data/lib/debug_agent/inspectors/security.rb

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

data/lib/debug_agent/inspectors/websocket.rb

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

data/lib/debug_agent/llm_client.rb

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

data/lib/debug_agent/version.rb

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

data/lib/debug_agent.rb

@@ -23,6 +23,18 @@ 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'
+require_relative 'debug_agent/inspectors/security'
+require_relative 'debug_agent/inspectors/health'
+require_relative 'debug_agent/inspectors/scheduler'
+require_relative 'debug_agent/inspectors/error_tracking'
+require_relative 'debug_agent/inspectors/websocket'
 
 module DebugAgent
   class Error < StandardError; end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: debug-agent
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.5.0
 platform: ruby
 authors:
 - ggcode
@@ -164,9 +164,18 @@ 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/error_tracking.rb
+- lib/debug_agent/inspectors/faraday.rb
 - lib/debug_agent/inspectors/gc.rb
+- lib/debug_agent/inspectors/health.rb
+- lib/debug_agent/inspectors/http_client.rb
 - lib/debug_agent/inspectors/http_tracker.rb
+- lib/debug_agent/inspectors/logging.rb
+- 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
@@ -174,9 +183,12 @@ files:
 - lib/debug_agent/inspectors/redis.rb
 - lib/debug_agent/inspectors/routes.rb
 - lib/debug_agent/inspectors/runtime.rb
+- lib/debug_agent/inspectors/scheduler.rb
+- lib/debug_agent/inspectors/security.rb
 - lib/debug_agent/inspectors/sidekiq.rb
 - lib/debug_agent/inspectors/system.rb
 - lib/debug_agent/inspectors/threads.rb
+- lib/debug_agent/inspectors/websocket.rb
 - lib/debug_agent/llm_client.rb
 - lib/debug_agent/middleware.rb
 - lib/debug_agent/system_prompt_builder.rb