lex-detect 0.1.3 → 0.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 119e238ddb0711af3bb4d23c5c65bb85c910420aa4ce79c1fe28c81950a38d0c
-  data.tar.gz: da4f50f6e3b1653c18d70617ab81630f3f9db6aa01cf6271205882f34df312f6
+  metadata.gz: 4be5aba6e8a22792e9f9fcbc2db27f18fe2d51f176044e7a18bdcc7db534becf
+  data.tar.gz: de631309f69e478a59d46d7ea9d8f0ff90f4ceff01e198424813e5bece7c00a1
 SHA512:
-  metadata.gz: 1f38552069181a4198433a821b64744f6bdf4cd42be0285c22eccfb4ef219f09f5d5d8a5825ac53c95ded7adb45278d5ca9ef20018c96f2dcac1ad61389da296
-  data.tar.gz: ecb32f15376b6079a1810c161a726f447e1aa6b07a3a187d894fe6393b31d608cc4c0a09227d52aefe88110e6f51ff3f3d9ba1e9e61772463587557600142896
+  metadata.gz: 18ef38241cf694a8244900735878fe5e5f49a70e3cedf50db94eb2e902aec8c84ecd3074e79a98320accea445e10b9145eca6590fc5fda4b2efce07e5338f737
+  data.tar.gz: af5e47f0566ca56b6b1eee75afd6620a5ec6201363e2c1d68ca89d47681221a0634979a52d9e941764204b3cdeb6745a4d9e33305537f548044c148425b137b0

data/CHANGELOG.md

@@ -1,12 +1,24 @@
 # Changelog
 
+## [0.1.4] - 2026-03-20
+
+### Changed
+- Version bump for deployment (0.1.3 was released before task observer and cancel task changes landed)
+
 ## [0.1.3] - 2026-03-20
 
 ### Added
-- `Runners::TaskObserver` for monitoring task failure patterns
+- `Runners::TaskObserver` for monitoring task failure patterns; supports DB-based `observe(since:)` and array-based `observe(tasks:)` calling styles
+- `check_timeout_risk` detects tasks running beyond 2x expected duration and emits `timeout_risk` alert
+- `check_repeated_failure` detects >=3 failures in 10 minutes per runner class
+- `publish_alerts` forwards structured alerts to AMQP when `Legion::Transport` is available
+- `record_observations` persists per-task observation records to `Legion::Data::Local` observer_events table
 - `check_and_publish_failure_patterns` publishes failure pattern events to AMQP for self-healing pipeline integration
 - `extract_gem_name` helper derives gem name from runner class string
 - `build_failure_pattern` creates structured failure pattern hash
+- `Runners::CancelTask` sets `cancelled_at` timestamp on tasks, guarded by `Legion::Data` availability
+- `Actors::ObserverTick` runs `TaskObserver#observe` every 60 seconds, passing `since:` for incremental DB scans
+- Local migration `20260320000001_create_observer_events` creates observer_events table for cognitive observation history
 
 ## [0.1.2] - 2026-03-19
 

data/lib/legion/extensions/detect/actors/observer_tick.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Detect
+      module Actors
+        class ObserverTick < Legion::Extensions::Actors::Every
+          def time = 60
+          def run_now? = false
+          def use_runner? = false
+          def check_subtask? = false
+          def generate_task? = false
+
+          def action(**_opts)
+            observer = Object.new.extend(Runners::TaskObserver)
+            observer.observe(since: @last_tick || (Time.now - 60))
+          ensure
+            @last_tick = Time.now
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/detect/local_migrations/20260320000001_create_observer_events.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+Sequel.migration do
+  up do
+    create_table?(:observer_events) do
+      primary_key :id
+      String :task_id, size: 64
+      String :runner, size: 255
+      String :rule, size: 64, null: true
+      String :severity, size: 16, null: true
+      Float :duration, null: true
+      Float :token_cost, null: true
+      DateTime :observed_at, null: false, default: Sequel::CURRENT_TIMESTAMP
+      index :task_id
+      index :rule
+      index :observed_at
+    end
+  end
+
+  down do
+    drop_table?(:observer_events)
+  end
+end

data/lib/legion/extensions/detect/runners/cancel_task.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Detect
+      module Runners
+        module CancelTask
+          def cancel_task(task_id:, **)
+            return { success: false, reason: :data_unavailable } unless defined?(Legion::Data)
+
+            task = Legion::Data::Model::Task[task_id]
+            return { success: false, reason: :not_found } unless task
+            return { success: false, reason: :already_cancelled } if task.respond_to?(:cancelled?) && task.cancelled?
+
+            task.update(cancelled_at: Time.now.utc)
+            { success: true, task_id: task_id, cancelled_at: task.cancelled_at }
+          rescue StandardError => e
+            { success: false, reason: :error, message: e.message }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/detect/runners/task_observer.rb

@@ -7,7 +7,9 @@ module Legion
         module TaskObserver
           extend self
 
-          def observe(tasks:, **)
+          def observe(tasks: nil, since: nil, **)
+            return observe_db(since: since) if tasks.nil?
+
             return { success: true, alerts: [] } unless tasks.is_a?(Array)
 
             alerts = generate_alerts(tasks)
@@ -19,6 +21,103 @@ module Legion
 
           private
 
+          def observe_db(since: nil)
+            return { alerts: [], observed: 0 } unless defined?(Legion::Data)
+
+            since ||= Time.now - 60
+            db_tasks = Legion::Data.connection[:tasks]
+                                   .where { started_at > since }
+                                   .all
+
+            alerts = db_tasks.filter_map { |task| evaluate_rules(task) }
+
+            publish_alerts(alerts) if alerts.any?
+            record_observations(db_tasks, alerts)
+
+            { alerts: alerts, observed: db_tasks.size }
+          rescue StandardError => e
+            { alerts: [], observed: 0, error: e.message }
+          end
+
+          def evaluate_rules(task)
+            check_timeout_risk(task) ||
+              check_repeated_failure(task) ||
+              check_cost_spike(task)
+          end
+
+          def check_timeout_risk(task, expected_duration: 120)
+            return nil unless task[:status] == 'running' && task[:started_at]
+
+            elapsed = Time.now - task[:started_at]
+            return nil unless elapsed > (expected_duration * 2)
+
+            {
+              rule:        'timeout_risk',
+              runner:      task[:runner_class],
+              task_id:     task[:id],
+              severity:    'warn',
+              detail:      "Running for #{elapsed.round}s (expected #{expected_duration}s)",
+              observed_at: Time.now.utc
+            }
+          end
+
+          def check_repeated_failure(task)
+            return nil unless defined?(Legion::Data) && task[:runner_class]
+
+            count = Legion::Data.connection[:tasks]
+                                .where(runner_class: task[:runner_class], status: 'failed')
+                                .where { started_at > Time.now - 600 }
+                                .count
+            return nil unless count >= 3
+
+            {
+              rule:        'repeated_failure',
+              runner:      task[:runner_class],
+              task_id:     task[:id],
+              severity:    'critical',
+              detail:      "#{count} failures in last 10 minutes",
+              observed_at: Time.now.utc
+            }
+          rescue StandardError
+            nil
+          end
+
+          def check_cost_spike(_task)
+            nil
+          end
+
+          def publish_alerts(alerts)
+            return unless defined?(Legion::Transport)
+
+            alerts.each do |alert|
+              Legion::Transport::Messages::Dynamic.new(
+                function: 'observer_alert',
+                payload:  alert
+              ).publish
+            end
+          rescue StandardError
+            nil
+          end
+
+          def record_observations(db_tasks, alerts)
+            return unless defined?(Legion::Data::Local)
+
+            db_tasks.each do |task|
+              alert = alerts.find { |a| a[:task_id] == task[:id] }
+              Legion::Data::Local.connection[:observer_events].insert(
+                task_id:     task[:id],
+                runner:      task[:runner_class],
+                rule:        alert&.dig(:rule),
+                severity:    alert&.dig(:severity),
+                duration:    task[:started_at] ? (Time.now - task[:started_at]).round(2) : nil,
+                token_cost:  nil,
+                observed_at: Time.now.utc
+              )
+            end
+          rescue StandardError
+            nil
+          end
+
           def generate_alerts(tasks)
             failed = tasks.select { |t| t[:status] == 'failed' }
             return [] if failed.empty?

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

@@ -3,7 +3,7 @@
 module Legion
   module Extensions
     module Detect
-      VERSION = '0.1.3'
+      VERSION = '0.1.4'
     end
   end
 end

data/lib/legion/extensions/detect.rb

@@ -5,6 +5,7 @@ require 'legion/extensions/detect/catalog'
 require 'legion/extensions/detect/scanner'
 require 'legion/extensions/detect/installer'
 require_relative 'detect/runners/task_observer'
+require_relative 'detect/runners/cancel_task'
 
 module Legion
   module Extensions
@@ -44,6 +45,7 @@ module Legion
 
       require_relative 'detect/actors/full_scan' if defined?(Legion::Extensions::Actors::Once)
       require_relative 'detect/actors/delta_scan' if defined?(Legion::Extensions::Actors::Every)
+      require_relative 'detect/actors/observer_tick' if defined?(Legion::Extensions::Actors::Every)
 
       if defined?(Legion::Data::Local)
         Legion::Data::Local.register_migrations(

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lex-detect
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 0.1.4
 platform: ruby
 authors:
 - Esity
@@ -29,9 +29,12 @@ files:
 - lib/legion/extensions/detect.rb
 - lib/legion/extensions/detect/actors/delta_scan.rb
 - lib/legion/extensions/detect/actors/full_scan.rb
+- lib/legion/extensions/detect/actors/observer_tick.rb
 - lib/legion/extensions/detect/catalog.rb
 - lib/legion/extensions/detect/installer.rb
 - lib/legion/extensions/detect/local_migrations/20260319000001_create_detect_results.rb
+- lib/legion/extensions/detect/local_migrations/20260320000001_create_observer_events.rb
+- lib/legion/extensions/detect/runners/cancel_task.rb
 - lib/legion/extensions/detect/runners/task_observer.rb
 - lib/legion/extensions/detect/scanner.rb
 - lib/legion/extensions/detect/version.rb