legionio 1.5.11 → 1.5.12

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2e6a0551564a834f76d460cb9ffed6cbc5e48e6dfe15a377c64e3a2c0540ac99
-  data.tar.gz: 0daf3944544ddcc630fdba40b35b8430b968db898c5dbfcfb9b348cee752ba48
+  metadata.gz: 2b5d012d4df4a245648fe489a4c998c34fa209c119b74301d209f29cdeb44977
+  data.tar.gz: 2f818144217a965f4353201773843cbfef1e151406b27996f6d493f144fa7de9
 SHA512:
-  metadata.gz: 7bfab92636665b30da8655966c8d88a6bc112da34f96eae8968118917e0c7ca525ba8bf59ac98b62ede1cc41e704cb1b57707e9b4ff90e625ffe2bb6237111a5
-  data.tar.gz: 210b3a406307fed54591b2bc3bda9e0a35f8af8cad45788d1d1137d40db8b61637c2450b74b18a772d6065f3451031ca9d07ad3722ea7d209e1c22907afe120f
+  metadata.gz: e436068fa3c9159a904fd9a57434916ad49a1e332b6220c2b89c290725094da4173aadea83c0656cccb564a05b0033521ad5ee37b6e0dc054eb83fa7facf2114
+  data.tar.gz: d83cacb7a7afddfb35892ef4d1183c32cce83c64bfa53fed51d599b8eb04a99589af9fc1202a778a7389b257ea2c9fdd9a71010f2ebfb2c8b2b193b54fbe31fe

data/CHANGELOG.md

@@ -1,5 +1,13 @@
 # Legion Changelog
 
+## [1.5.12] - 2026-03-25
+
+### Added
+- `GET /api/stats` endpoint — comprehensive daemon runtime stats: extensions (loaded/actor counts), gaia (status/channels/phases), transport (session/channels), cache/cache_local (pool stats), llm (provider health/routing), data/data_local (pool/tuning via legion-data stats), api (puma threads/routes)
+
+### Changed
+- Bumped gemspec dependency: legion-data >= 1.6.0 (required for `Legion::Data.stats`)
+
 ## [1.5.11] - 2026-03-25
 
 ### Added

data/CLAUDE.md

@@ -633,6 +633,7 @@ rack-test, rake, rspec, rubocop, rubocop-rspec, simplecov
 | `lib/legion/telemetry.rb` | Opt-in OpenTelemetry tracing: `with_span` wrapper, `sanitize_attributes`, `record_exception` |
 | `lib/legion/metrics.rb` | Opt-in Prometheus metrics: event-driven counters, pull-based gauges, `prometheus-client` guarded |
 | `lib/legion/api/metrics.rb` | `GET /metrics` Prometheus text-format endpoint with gauge refresh |
+| `lib/legion/api/stats.rb` | `GET /api/stats` comprehensive daemon runtime stats (extensions, gaia, transport, cache, llm, data, api) |
 | `lib/legion/chat/notification_queue.rb` | Thread-safe priority queue for background notifications (critical/info/debug) |
 | `lib/legion/chat/notification_bridge.rb` | Event-driven bridge: matches Legion events to chat notifications via fnmatch patterns |
 | `lib/legion/api/middleware/auth.rb` | Auth: JWT Bearer auth middleware (real token validation, skip paths for health/ready) |

data/legionio.gemspec

@@ -54,7 +54,7 @@ Gem::Specification.new do |spec|
 
   spec.add_dependency 'legion-cache', '>= 1.3.16'
   spec.add_dependency 'legion-crypt', '>= 1.4.12'
-  spec.add_dependency 'legion-data', '>= 1.5.3'
+  spec.add_dependency 'legion-data', '>= 1.6.0'
   spec.add_dependency 'legion-json', '>= 1.2.1'
   spec.add_dependency 'legion-logging', '>= 1.3.2'
   spec.add_dependency 'legion-settings', '>= 1.3.19'

data/lib/legion/api/openapi.rb

@@ -155,6 +155,7 @@ module Legion
           .merge(gaia_paths)
           .merge(apollo_paths)
           .merge(openapi_paths)
+          .merge(stats_paths)
       end
       private_class_method :paths
 
@@ -1661,6 +1662,42 @@ module Legion
         }
       end
       private_class_method :openapi_paths
+
+      def self.stats_paths
+        {
+          '/api/stats' => {
+            get: {
+              tags:        ['Stats'],
+              summary:     'Comprehensive daemon runtime stats',
+              description: 'Returns runtime statistics for all subsystems: extensions, gaia, transport, cache, llm, data, and api. ' \
+                           'Each section collects independently — one subsystem failure does not affect others.',
+              operationId: 'getStats',
+              responses:   {
+                '200' => ok_response('Stats', wrap_data('StatsObject').merge(
+                                                properties: {
+                                                  data: {
+                                                    type:       'object',
+                                                    properties: {
+                                                      extensions:  { type: 'object' },
+                                                      gaia:        { type: 'object' },
+                                                      transport:   { type: 'object' },
+                                                      cache:       { type: 'object' },
+                                                      cache_local: { type: 'object' },
+                                                      llm:         { type: 'object' },
+                                                      data:        { type: 'object' },
+                                                      data_local:  { type: 'object' },
+                                                      api:         { type: 'object' }
+                                                    }
+                                                  },
+                                                  meta: { '$ref' => '#/components/schemas/Meta' }
+                                                }
+                                              ))
+              }
+            }
+          }
+        }
+      end
+      private_class_method :stats_paths
     end
   end
 end

data/lib/legion/api/stats.rb

@@ -0,0 +1,219 @@
+# frozen_string_literal: true
+
+module Legion
+  class API < Sinatra::Base
+    module Routes
+      module Stats
+        def self.registered(app)
+          app.get '/api/stats' do
+            result = {}
+            result[:extensions]  = Routes::Stats.collect_extensions
+            result[:gaia]        = Routes::Stats.collect_gaia
+            result[:transport]   = Routes::Stats.collect_transport
+            result[:cache]       = Routes::Stats.collect_cache
+            result[:cache_local] = Routes::Stats.collect_cache_local
+            result[:llm]         = Routes::Stats.collect_llm
+            result[:data]        = Routes::Stats.collect_data
+            result[:data_local]  = Routes::Stats.collect_data_local
+            result[:api]         = Routes::Stats.collect_api
+            json_response(result)
+          end
+        end
+
+        EXTENSION_IVARS = {
+          loaded:       :@loaded_extensions,
+          discovered:   :@extensions,
+          subscription: :@subscription_tasks,
+          every:        :@timer_tasks,
+          poll:         :@poll_tasks,
+          once:         :@once_tasks,
+          loop:         :@loop_tasks,
+          running:      :@running_instances
+        }.freeze
+
+        class << self
+          def collect_extensions
+            ext = Legion::Extensions
+            EXTENSION_IVARS.transform_values { |ivar| ext.instance_variable_get(ivar)&.count || 0 }
+          rescue StandardError => e
+            { error: e.message }
+          end
+
+          def collect_gaia
+            return { started: false } unless defined?(Legion::Gaia) && Legion::Gaia.respond_to?(:started?) && Legion::Gaia.started?
+
+            Legion::Gaia.status
+          rescue StandardError => e
+            { error: e.message }
+          end
+
+          def collect_transport
+            conn = Legion::Transport::Connection
+            connected = begin
+              Legion::Settings[:transport][:connected]
+            rescue StandardError
+              false
+            end
+            connector = defined?(Legion::Transport::TYPE) ? Legion::Transport::TYPE.to_s : 'unknown'
+
+            info = { connected: connected, connector: connector }
+
+            session = conn.session
+            if session.respond_to?(:open?) && session.open?
+              info[:session_open] = true
+              info[:channel_max] = session.channel_max if session.respond_to?(:channel_max)
+              # Bunny tracks open channels in @channels hash
+              channels = session.instance_variable_get(:@channels)
+              info[:channels_open] = channels.is_a?(Hash) ? channels.count : nil
+            else
+              info[:session_open] = false
+            end
+
+            info[:build_session_open] = conn.build_session_open?
+            info[:lite_mode] = conn.lite_mode?
+            info
+          rescue StandardError => e
+            { error: e.message }
+          end
+
+          def collect_cache
+            return { connected: false } unless defined?(Legion::Cache)
+
+            info = { connected: Legion::Cache.connected? }
+            info[:using_local]  = Legion::Cache.using_local? if Legion::Cache.respond_to?(:using_local?)
+            info[:using_memory] = Legion::Cache.instance_variable_get(:@using_memory) == true
+            info[:driver] = begin
+              Legion::Settings[:cache][:driver]
+            rescue StandardError
+              nil
+            end
+
+            if Legion::Cache.connected? && Legion::Cache.respond_to?(:size)
+              info[:pool_size] = begin
+                Legion::Cache.size
+              rescue StandardError
+                nil
+              end
+              info[:pool_available] = begin
+                Legion::Cache.available
+              rescue StandardError
+                nil
+              end
+            end
+            info
+          rescue StandardError => e
+            { error: e.message }
+          end
+
+          def collect_cache_local
+            return { connected: false } unless defined?(Legion::Cache::Local)
+
+            info = { connected: Legion::Cache::Local.connected? }
+            if Legion::Cache::Local.connected?
+              info[:pool_size] = begin
+                Legion::Cache::Local.size
+              rescue StandardError
+                nil
+              end
+              info[:pool_available] = begin
+                Legion::Cache::Local.available
+              rescue StandardError
+                nil
+              end
+            end
+            info
+          rescue StandardError => e
+            { error: e.message }
+          end
+
+          def collect_llm
+            return { started: false } unless defined?(Legion::LLM) && Legion::LLM.started?
+
+            info = { started: true }
+            s = Legion::LLM.settings
+            info[:default_model]    = s[:default_model]
+            info[:default_provider] = s[:default_provider]
+            info[:pipeline_enabled] = s[:pipeline_enabled] == true
+
+            if defined?(Legion::LLM::Router) && Legion::LLM::Router.routing_enabled?
+              info[:routing_enabled] = true
+              tracker = Legion::LLM::Router.health_tracker
+              if tracker
+                providers = s[:providers] || {}
+                info[:provider_health] = providers.each_with_object({}) do |(name, _cfg), h|
+                  h[name] = { circuit: tracker.circuit_state(name)&.to_s }
+                rescue StandardError
+                  nil
+                end
+              end
+            else
+              info[:routing_enabled] = false
+            end
+
+            if defined?(Legion::LLM::ConversationStore)
+              store = Legion::LLM::ConversationStore
+              info[:conversations] = store.respond_to?(:size) ? store.size : nil
+            end
+            info
+          rescue StandardError => e
+            { error: e.message }
+          end
+
+          def collect_data
+            return { connected: false } unless defined?(Legion::Data) && Legion::Settings[:data][:connected]
+
+            if Legion::Data.respond_to?(:stats)
+              stats = Legion::Data.stats
+              stats[:shared] || stats
+            else
+              { connected: true, adapter: begin
+                Legion::Data::Connection.adapter
+              rescue StandardError
+                nil
+              end }
+            end
+          rescue StandardError => e
+            { error: e.message }
+          end
+
+          def collect_data_local
+            return { connected: false } unless defined?(Legion::Data::Local) && Legion::Data::Local.connected?
+
+            if Legion::Data::Local.respond_to?(:stats)
+              Legion::Data::Local.stats
+            else
+              { connected: true }
+            end
+          rescue StandardError => e
+            { error: e.message }
+          end
+
+          def collect_api
+            port = Legion::Settings.dig(:api, :port) || Legion::Settings.dig(:http, :port) || 4567
+            info = { port: port }
+
+            # Puma thread pool stats if available
+            puma_server = Puma::Server.current if defined?(Puma::Server) && Puma::Server.respond_to?(:current)
+            if puma_server.respond_to?(:pool_capacity)
+              info[:puma] = {
+                pool_capacity: puma_server.pool_capacity,
+                max_threads:   puma_server.max_threads,
+                running:       puma_server.running,
+                backlog:       puma_server.backlog
+              }
+            end
+
+            info[:routes] = begin
+              Legion::API.routes.values.flatten.count
+            rescue StandardError
+              nil
+            end
+            info
+          rescue StandardError => e
+            { error: e.message }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/api.rb

@@ -45,6 +45,7 @@ require_relative 'api/marketplace'
 require_relative 'api/apollo'
 require_relative 'api/costs'
 require_relative 'api/traces'
+require_relative 'api/stats'
 require_relative 'api/graphql' if defined?(GraphQL)
 
 module Legion
@@ -135,6 +136,7 @@ module Legion
     register Routes::Apollo
     register Routes::Costs
     register Routes::Traces
+    register Routes::Stats
     register Routes::GraphQL if defined?(Routes::GraphQL)
 
     use Legion::API::Middleware::RequestLogger

data/lib/legion/cli/debug_command.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require 'fileutils'
 require 'net/http'
 require 'json'
 require 'socket'
@@ -23,35 +24,58 @@ module Legion
       desc 'dump', 'Full diagnostic dump (markdown, suitable for piping to LLM)'
       default_task :dump
       def dump
-        sections = {}
-
-        sections[:versions]    = section_versions
-        sections[:doctor]      = section_doctor
-        sections[:config]      = section_config
-        sections[:gems]        = section_gems
-        sections[:extensions]  = section_extensions
-        sections[:rbac]        = section_rbac
-        sections[:llm]         = section_llm
-        sections[:gaia]        = section_gaia
-        sections[:transport]   = section_transport
-        sections[:events]      = section_events
-        sections[:apollo]      = section_apollo
-        sections[:remote_redis] = section_remote_redis
-        sections[:local_redis]  = section_local_redis
-        sections[:postgresql]   = section_postgresql
-        sections[:rabbitmq]     = section_rabbitmq
-        sections[:api_health]   = section_api_health
-
-        if options[:json]
-          puts ::JSON.pretty_generate(sections)
-        else
-          render_markdown(sections)
-        end
+        sections = collect_all_sections
+
+        output = if options[:json]
+                   ::JSON.pretty_generate(sections)
+                 else
+                   build_markdown(sections)
+                 end
+
+        puts output
+
+        path = write_dump_file(output)
+        warn "Saved to #{path}" if path
       end
 
+      DEBUG_DIR = File.expand_path('~/.legionio/debug')
+
       no_commands do # rubocop:disable Metrics/BlockLength
         private
 
+        def collect_all_sections
+          sections = {}
+          sections[:versions]     = section_versions
+          sections[:doctor]       = section_doctor
+          sections[:config]       = section_config
+          sections[:gems]         = section_gems
+          sections[:extensions]   = section_extensions
+          sections[:rbac]         = section_rbac
+          sections[:llm]          = section_llm
+          sections[:gaia]         = section_gaia
+          sections[:transport]    = section_transport
+          sections[:events]       = section_events
+          sections[:apollo]       = section_apollo
+          sections[:remote_redis] = section_remote_redis
+          sections[:local_redis]  = section_local_redis
+          sections[:postgresql]   = section_postgresql
+          sections[:rabbitmq]     = section_rabbitmq
+          sections[:api_health]   = section_api_health
+          sections
+        end
+
+        def write_dump_file(output)
+          FileUtils.mkdir_p(DEBUG_DIR)
+          ext = options[:json] ? 'json' : 'md'
+          filename = "#{Time.now.utc.strftime('%Y-%m-%d_%H%M%S')}.#{ext}"
+          path = File.join(DEBUG_DIR, filename)
+          File.write(path, output)
+          path
+        rescue StandardError => e
+          warn "Warning: could not write debug file: #{e.message}"
+          nil
+        end
+
         def api_host
           options[:host] || '127.0.0.1'
         end
@@ -390,37 +414,38 @@ module Legion
           end
         end
 
-        def render_markdown(sections)
-          puts '# LegionIO Diagnostic Dump'
-          puts
-          puts "Generated: #{Time.now.utc.iso8601}"
-          puts
-
-          md_section('Versions', sections[:versions])
-          md_section('Doctor Checks', sections[:doctor])
-          md_section('Configuration (redacted)', sections[:config])
-          md_section('Installed Gems', sections[:gems])
-          md_section('Loaded Extensions', sections[:extensions])
-          md_section('RBAC Roles', sections[:rbac])
-          md_section('LLM Status', sections[:llm])
-          md_section('GAIA Status', sections[:gaia])
-          md_section('Transport Status', sections[:transport])
-          md_section('Recent Events (last 20)', sections[:events])
-          md_section('Apollo Stats', sections[:apollo])
-          md_section('Remote Redis', sections[:remote_redis])
-          md_section('Local Redis', sections[:local_redis])
-          md_section('PostgreSQL', sections[:postgresql])
-          md_section('RabbitMQ', sections[:rabbitmq])
-          md_section('API Health', sections[:api_health])
-        end
+        def build_markdown(sections)
+          lines = []
+          lines << '# LegionIO Diagnostic Dump'
+          lines << ''
+          lines << "Generated: #{Time.now.utc.iso8601}"
+          lines << ''
+
+          { 'Versions'                 => :versions,
+            'Doctor Checks'            => :doctor,
+            'Configuration (redacted)' => :config,
+            'Installed Gems'           => :gems,
+            'Loaded Extensions'        => :extensions,
+            'RBAC Roles'               => :rbac,
+            'LLM Status'               => :llm,
+            'GAIA Status'              => :gaia,
+            'Transport Status'         => :transport,
+            'Recent Events (last 20)'  => :events,
+            'Apollo Stats'             => :apollo,
+            'Remote Redis'             => :remote_redis,
+            'Local Redis'              => :local_redis,
+            'PostgreSQL'               => :postgresql,
+            'RabbitMQ'                 => :rabbitmq,
+            'API Health'               => :api_health }.each do |title, key|
+            lines << "## #{title}"
+            lines << ''
+            lines << '```json'
+            lines << ::JSON.pretty_generate(sections[key])
+            lines << '```'
+            lines << ''
+          end
 
-        def md_section(title, data)
-          puts "## #{title}"
-          puts
-          puts '```json'
-          puts ::JSON.pretty_generate(data)
-          puts '```'
-          puts
+          lines.join("\n")
         end
       end
     end

data/lib/legion/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Legion
-  VERSION = '1.5.11'
+  VERSION = '1.5.12'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: legionio
 version: !ruby/object:Gem::Version
-  version: 1.5.11
+  version: 1.5.12
 platform: ruby
 authors:
 - Esity
@@ -253,14 +253,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.5.3
+        version: 1.6.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.5.3
+        version: 1.6.0
 - !ruby/object:Gem::Dependency
   name: legion-json
   requirement: !ruby/object:Gem::Requirement
@@ -479,6 +479,7 @@ files:
 - lib/legion/api/relationships.rb
 - lib/legion/api/schedules.rb
 - lib/legion/api/settings.rb
+- lib/legion/api/stats.rb
 - lib/legion/api/tasks.rb
 - lib/legion/api/tenants.rb
 - lib/legion/api/token.rb