lex-telemetry 0.1.6 → 0.1.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f468345bff8197f58b2ef7736b8c03e2ede0e6521505bbd4c8b73e6f9c606a89
-  data.tar.gz: e4e9783b090af3812310e385e51c5a5950b57868faa7c87863d77a8ad7a6b1e2
+  metadata.gz: 38dd588b667de5c28ca831f41b9bb3e59a2df3ddb1da73760032b64bb868ada6
+  data.tar.gz: 16d9198d26d37a76fbdce09918dc46300a3322927fceb5d767b291f1b44657ce
 SHA512:
-  metadata.gz: 0fac05554a0955707202e43c131dcfa1d54339e0750ff3f6640e5805cd6e92a60a3a71672f87b4415bd5d16de3e8ac4de3b8f005e754a01a570ea6c2a39eabc2
-  data.tar.gz: 4f5e12b043042b264e257f8cf99747aa020376083bbd9c727429e4cc702788f2f4b1a69a9d13962febc5fbc4cd22be00f893050609125b598588e1947e71951f
+  metadata.gz: da852fb40d7273f9f4f7074c1cc94dcaca5411511d1b183df78d327cd290d312aee0109d708d8e5227749383bbae0c01a37022b508ecd518cdbd0721bb755858
+  data.tar.gz: 7fcb82807a28ecabb01d95fa0f227067ab1ee50679386132914efae509fa6449846b87f2c70fa83b31b793cb9a56f3536d273c3704230cf86d352675bf87da7c

data/.github/workflows/ci.yml

@@ -10,8 +10,8 @@ jobs:
   ci:
     uses: LegionIO/.github/.github/workflows/ci.yml@main
 
-  lint:
-    uses: LegionIO/.github/.github/workflows/lint-patterns.yml@main
+  excluded-files:
+    uses: LegionIO/.github/.github/workflows/excluded-files.yml@main
 
   security:
     uses: LegionIO/.github/.github/workflows/security-scan.yml@main
@@ -27,8 +27,8 @@ jobs:
     uses: LegionIO/.github/.github/workflows/stale.yml@main
 
   release:
-    needs: [ci, lint]
+    needs: [ci, excluded-files]
     if: github.event_name == 'push' && github.ref == 'refs/heads/main'
     uses: LegionIO/.github/.github/workflows/release.yml@main
     secrets:
-      rubygems-api-key: ${{ secrets.RUBYGEMS_API_KEY }}
+      rubygems-api-key: ${{ secrets.RUBYGEMS_API_KEY }}

data/.rubocop.yml

@@ -1,67 +1,18 @@
-AllCops:
-  TargetRubyVersion: 3.4
-  NewCops: enable
-  SuggestExtensions: false
+inherit_gem:
+  rubocop-legion: config/lex.yml
 
-Layout/LineLength:
-  Max: 160
-
-Layout/SpaceAroundEqualsInParameterDefault:
-  EnforcedStyle: space
-
-Layout/HashAlignment:
-  EnforcedHashRocketStyle: table
-  EnforcedColonStyle: table
-
-Metrics/MethodLength:
-  Max: 50
-
-Metrics/ClassLength:
-  Max: 1500
-
-Metrics/ModuleLength:
-  Max: 1500
-
-Metrics/BlockLength:
-  Max: 40
-  Exclude:
-    - 'spec/**/*'
-
-Metrics/AbcSize:
-  Max: 60
-
-Metrics/CyclomaticComplexity:
-  Max: 15
-
-Metrics/PerceivedComplexity:
-  Max: 17
-
-Style/Documentation:
-  Enabled: false
-
-Style/SymbolArray:
-  Enabled: true
-
-Style/FrozenStringLiteralComment:
-  Enabled: true
-  EnforcedStyle: always
-
-Naming/FileName:
+# Actors define `def time` as instance method — cop looks for DSL call, false positive
+Legion/Extension/EveryActorRequiresTime:
   Enabled: false
 
-Naming/PredicateMethod:
+# Runner module is designed for include into actors; not standalone
+Legion/Extension/RunnerIncludeHelpers:
   Enabled: false
 
-Gemspec/DevelopmentDependencies:
+# Class instance variables use Concurrent::Hash/AtomicFixnum — thread-safe by design
+ThreadSafety/ClassInstanceVariable:
   Enabled: false
 
+# TelemetryEvent#build legitimately requires many named parameters for type safety
 Metrics/ParameterLists:
   Enabled: false
-
-Lint/EmptyClass:
-  Exclude:
-    - 'spec/**/*'
-
-Style/MultilineIfModifier:
-  Exclude:
-    - 'spec/**/*'

data/CHANGELOG.md

@@ -1,5 +1,17 @@
 # Changelog
 
+## [0.1.8] - 2026-03-31
+
+### Added
+- `StatsReporter` actor (Every 60s): periodically calls `system_stats` to collect and ship aggregate subsystem metrics
+- `system_stats` runner method: collects stats from Transport, Cache, Data, LLM, Extensions, and GAIA subsystems; publishes via telemetry exchange
+- `Helpers::SubsystemStats`: per-subsystem collectors with graceful guards (returns nil when subsystem not loaded)
+
+## [0.1.7] - 2026-03-30
+
+### Changed
+- update to rubocop-legion 0.1.7, resolve all offenses
+
 ## [0.1.6] - 2026-03-26
 
 ### Changed

data/Gemfile

@@ -4,3 +4,4 @@ source 'https://rubygems.org'
 gemspec
 
 gem 'concurrent-ruby'
+gem 'rubocop-legion', '~> 0.1'

data/lex-telemetry.gemspec

@@ -37,7 +37,6 @@ Gem::Specification.new do |spec|
   spec.add_dependency 'legion-settings',   '>= 1.3.14'
   spec.add_dependency 'legion-transport',  '>= 1.3.9'
 
-  spec.add_development_dependency 'rake'
   spec.add_development_dependency 'rspec'
   spec.add_development_dependency 'rubocop'
   spec.add_development_dependency 'rubocop-rspec'

data/lib/legion/extensions/telemetry/actors/stats_reporter.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Telemetry
+      module Actor
+        class StatsReporter < Legion::Extensions::Actors::Every
+          def runner_class
+            'Legion::Extensions::Telemetry::Runners::Telemetry'
+          end
+
+          def runner_function
+            'system_stats'
+          end
+
+          def time
+            60
+          end
+
+          def run_now?
+            false
+          end
+
+          def use_runner?
+            false
+          end
+
+          def check_subtask?
+            false
+          end
+
+          def generate_task?
+            false
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/telemetry/helpers/subsystem_stats.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Telemetry
+      module Helpers
+        module SubsystemStats
+          module_function
+
+          def collect_transport
+            return nil unless Legion.const_defined?(:Transport, false)
+
+            stats = {}
+
+            if Legion::Transport.respond_to?(:connection) && Legion::Transport.connection.respond_to?(:status)
+              stats[:connection_status] = Legion::Transport.connection.status.to_s
+            end
+
+            if Legion::Transport.respond_to?(:connection) && Legion::Transport.connection.respond_to?(:channel_max)
+              stats[:channel_max] = Legion::Transport.connection.channel_max
+            end
+
+            stats
+          rescue StandardError => _e
+            nil
+          end
+
+          def collect_cache
+            return nil unless defined?(Legion::Cache)
+
+            stats = {}
+
+            if Legion::Cache.respond_to?(:stats)
+              raw = Legion::Cache.stats
+              stats.merge!(raw) if raw.is_a?(Hash)
+            end
+
+            stats
+          rescue StandardError => _e
+            nil
+          end
+
+          def collect_data
+            return nil unless defined?(Legion::Data)
+
+            stats = {}
+
+            stats[:connected] = Legion::Data.connected? if Legion::Data.respond_to?(:connected?)
+
+            stats[:pool_size] = Legion::Data::Pool.size if defined?(Legion::Data::Pool) && Legion::Data::Pool.respond_to?(:size)
+
+            stats
+          rescue StandardError => _e
+            nil
+          end
+
+          def collect_llm
+            return nil unless defined?(Legion::LLM)
+
+            stats = {}
+
+            if Legion::LLM.respond_to?(:pipeline_stats)
+              raw = Legion::LLM.pipeline_stats
+              stats.merge!(raw) if raw.is_a?(Hash)
+            end
+
+            stats
+          rescue StandardError => _e
+            nil
+          end
+
+          def collect_extensions
+            return nil unless defined?(Legion::Extensions)
+
+            stats = {}
+
+            if Legion::Extensions.respond_to?(:loaded)
+              loaded = Legion::Extensions.loaded
+              stats[:loaded_count] = loaded.is_a?(Array) ? loaded.length : loaded.to_i
+            end
+
+            stats
+          rescue StandardError => _e
+            nil
+          end
+
+          def collect_gaia
+            return nil unless defined?(Legion::Gaia)
+
+            stats = {}
+
+            stats[:tick_count] = Legion::Gaia.tick_count if Legion::Gaia.respond_to?(:tick_count)
+
+            stats[:active_phase] = Legion::Gaia.active_phase.to_s if Legion::Gaia.respond_to?(:active_phase)
+
+            stats
+          rescue StandardError => _e
+            nil
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/telemetry/parsers/claude_code.rb

@@ -18,11 +18,11 @@ module Legion
             first_line = File.open(path, &:readline)
             data = ::JSON.parse(first_line)
             data.is_a?(Hash) && (data.key?('sessionId') || data.key?('parentUuid'))
-          rescue StandardError
+          rescue StandardError => _e
             false
           end
 
-          def parse(path, offset: 0, &block)
+          def parse(path, offset: 0, &)
             pending_tools = {}
             session_id = nil
 
@@ -36,13 +36,13 @@ module Legion
 
                 if first_line && offset.zero?
                   session_id = data['sessionId'] || data['uuid'] || SecureRandom.uuid
-                  block.call(Helpers::TelemetryEvent.build(
-                               event_type: :session_start,
-                               session_id: session_id,
-                               source:     source_name,
-                               timestamp:  timestamp,
-                               metadata:   { version: data['version'] }
-                             ))
+                  yield(Helpers::TelemetryEvent.build(
+                    event_type: :session_start,
+                    session_id: session_id,
+                    source:     source_name,
+                    timestamp:  timestamp,
+                    metadata:   { version: data['version'] }
+                  ))
                   first_line = false
                   next
                 end
@@ -51,9 +51,9 @@ module Legion
                 msg = data['message']
                 next unless msg.is_a?(Hash)
 
-                process_assistant(msg, session_id, timestamp, pending_tools, &block) if msg['role'] == 'assistant'
-                process_tool_result(msg, session_id, timestamp, pending_tools, &block) if msg['role'] == 'user'
-              rescue ::JSON::ParserError
+                process_assistant(msg, session_id, timestamp, pending_tools, &) if msg['role'] == 'assistant'
+                process_tool_result(msg, session_id, timestamp, pending_tools, &) if msg['role'] == 'user'
+              rescue ::JSON::ParserError => _e
                 next
               end
 
@@ -63,7 +63,7 @@ module Legion
 
           private
 
-          def process_assistant(msg, session_id, timestamp, pending_tools, &block)
+          def process_assistant(msg, session_id, timestamp, pending_tools)
             content = msg['content']
             usage = msg['usage']
 
@@ -85,16 +85,16 @@ module Legion
             has_tool_use = content.is_a?(Array) && content.any? { |b| b['type'] == 'tool_use' }
             return if has_tool_use
 
-            block.call(Helpers::TelemetryEvent.build(
-                         event_type: :llm_request,
-                         session_id: session_id,
-                         source:     source_name,
-                         timestamp:  timestamp,
-                         tokens:     extract_tokens(usage)
-                       ))
+            yield(Helpers::TelemetryEvent.build(
+              event_type: :llm_request,
+              session_id: session_id,
+              source:     source_name,
+              timestamp:  timestamp,
+              tokens:     extract_tokens(usage)
+            ))
           end
 
-          def process_tool_result(msg, session_id, timestamp, pending_tools, &block)
+          def process_tool_result(msg, session_id, timestamp, pending_tools)
             content = msg['content']
             return unless content.is_a?(Array)
 
@@ -106,16 +106,16 @@ module Legion
 
               duration_ms = ((timestamp - pending[:timestamp]) * 1000).to_i if timestamp && pending[:timestamp]
 
-              block.call(Helpers::TelemetryEvent.build(
-                           event_type:  :tool_call,
-                           session_id:  session_id,
-                           source:      source_name,
-                           timestamp:   pending[:timestamp],
-                           tool_name:   pending[:tool_name],
-                           tool_input:  pending[:tool_input],
-                           duration_ms: duration_ms,
-                           tokens:      pending[:tokens]
-                         ))
+              yield(Helpers::TelemetryEvent.build(
+                event_type:  :tool_call,
+                session_id:  session_id,
+                source:      source_name,
+                timestamp:   pending[:timestamp],
+                tool_name:   pending[:tool_name],
+                tool_input:  pending[:tool_input],
+                duration_ms: duration_ms,
+                tokens:      pending[:tokens]
+              ))
             end
           end
 
@@ -134,7 +134,7 @@ module Legion
             return nil unless str
 
             Time.parse(str)
-          rescue ArgumentError
+          rescue ArgumentError => _e
             nil
           end
 

data/lib/legion/extensions/telemetry/runners/telemetry.rb

@@ -94,7 +94,7 @@ module Legion
           def publish_pending(**_opts)
             if privacy_mode?
               count = event_store.pending.length
-              Legion::Logging.info "lex-telemetry: privacy mode active, suppressing #{count} pending events (local logging only)" if defined?(Legion::Logging)
+              Legion::Logging.info "lex-telemetry: privacy mode active, suppressing #{count} pending events (local logging only)" # rubocop:disable Legion/HelperMigration/DirectLogging
               event_store.pending.clear
               return { success: true, published: 0, suppressed: true, reason: 'enterprise_data_privacy is enabled' }
             end
@@ -109,7 +109,7 @@ module Legion
                 Transport::Messages::TelemetryMessage.new.publish(event, routing_key: routing_key)
                 published += 1
               end
-            rescue StandardError
+            rescue StandardError => _e
               event_store.pending.push(event)
             end
 
@@ -149,7 +149,7 @@ module Legion
                 high_water_mark.set(path: path, offset: new_offset)
                 files_processed += 1
                 events_ingested += count
-              rescue StandardError
+              rescue StandardError => _e
                 next
               end
             end
@@ -174,7 +174,7 @@ module Legion
             affinity = if defined?(Legion::Settings)
                          begin
                            Legion::Settings.dig(:region, :default_affinity)
-                         rescue StandardError
+                         rescue StandardError => _e
                            'prefer_local'
                          end
                        else
@@ -202,6 +202,31 @@ module Legion
             end
           end
 
+          def system_stats(**_opts)
+            stats = {
+              transport:  Helpers::SubsystemStats.collect_transport,
+              cache:      Helpers::SubsystemStats.collect_cache,
+              data:       Helpers::SubsystemStats.collect_data,
+              llm:        Helpers::SubsystemStats.collect_llm,
+              extensions: Helpers::SubsystemStats.collect_extensions,
+              gaia:       Helpers::SubsystemStats.collect_gaia,
+              timestamp:  Time.now.to_i
+            }.compact
+
+            begin
+              if defined?(Legion::Extensions::Telemetry::Transport::Messages::TelemetryMessage)
+                payload = { event_type: :system_stats, source: :system, data: stats }
+                Transport::Messages::TelemetryMessage.new.publish(payload)
+              end
+            rescue StandardError => _e
+              nil
+            end
+
+            { success: true, stats: stats }
+          rescue StandardError => e
+            { success: false, error: e.message }
+          end
+
           def reset!
             @event_store = nil
             @parsers = nil

data/lib/legion/extensions/telemetry/version.rb

@@ -3,7 +3,7 @@
 module Legion
   module Extensions
     module Telemetry
-      VERSION = '0.1.6'
+      VERSION = '0.1.8'
     end
   end
 end

data/lib/legion/extensions/telemetry.rb

@@ -8,12 +8,13 @@ require 'legion/extensions/telemetry/parsers/claude_code'
 require 'legion/extensions/telemetry/helpers/event_store'
 require 'legion/extensions/telemetry/helpers/stats'
 require 'legion/extensions/telemetry/helpers/high_water_mark'
+require 'legion/extensions/telemetry/helpers/subsystem_stats'
 require 'legion/extensions/telemetry/runners/telemetry'
 
 module Legion
   module Extensions
     module Telemetry
-      extend Legion::Extensions::Core if Legion::Extensions.const_defined? :Core
+      extend Legion::Extensions::Core if Legion::Extensions.const_defined? :Core, false
 
       def self.remote_invocable?
         false

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lex-telemetry
 version: !ruby/object:Gem::Version
-  version: 0.1.6
+  version: 0.1.8
 platform: ruby
 authors:
 - Esity
@@ -121,20 +121,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 1.3.9
-- !ruby/object:Gem::Dependency
-  name: rake
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -215,10 +201,12 @@ files:
 - lib/legion/extensions/telemetry/actors/collector.rb
 - lib/legion/extensions/telemetry/actors/publisher.rb
 - lib/legion/extensions/telemetry/actors/region_reporter.rb
+- lib/legion/extensions/telemetry/actors/stats_reporter.rb
 - lib/legion/extensions/telemetry/helpers/event_store.rb
 - lib/legion/extensions/telemetry/helpers/high_water_mark.rb
 - lib/legion/extensions/telemetry/helpers/scrubber.rb
 - lib/legion/extensions/telemetry/helpers/stats.rb
+- lib/legion/extensions/telemetry/helpers/subsystem_stats.rb
 - lib/legion/extensions/telemetry/helpers/telemetry_event.rb
 - lib/legion/extensions/telemetry/parsers/base.rb
 - lib/legion/extensions/telemetry/parsers/claude_code.rb