legionio 1.7.6 → 1.7.12

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 30ac0f16cae1d42de41e7ed922e2fd75d96093017f7d562e2596b9c20bea99b6
-  data.tar.gz: 23fe67ca7f6171ea6e0ed13d50b382e78e1a7df4402cf1fe8174fcfea7d92ceb
+  metadata.gz: 60c67de284b066264f07c3ad829b8d193b66d85ae900af468dd7a13165695da8
+  data.tar.gz: 8fd7ab97436343722619c6c77e0aaff9b6f664609db1b81a0daff97c6692f419
 SHA512:
-  metadata.gz: ada4b04b1a274b66d60ab44ae9abe4b8ea998576d7d4a5b679ab3099ad91615924fe4646f671b544820d0b1db6e2bbcc0ceea84f2e5ed762e3f1321500017d99
-  data.tar.gz: b1a5d03f53e03039321f54529b0eae7abdc82462a20ee0dd0c1cb88927b15f606a07472b69cdeacc488217fc941d62074f83e567c09d3d26f21c821328309f14
+  metadata.gz: 2fde83c468f409a35fc9e02d1dc39d969a0229d32c8b592162789683f21afa31df90763792a1c4c74cb74f13ef21f1288e125d78b2b68ac2f9d724a08eee1e77
+  data.tar.gz: d10be584f4e30e1f164545c5c6e72f2e3cfa627e19675021edaf18ee6224d3f66d92ce50fcaf44b40caf0e47515e61d137e921f3903e5cab34254245fcd84bfa

data/.rubocop.yml

@@ -5,6 +5,8 @@ AllCops:
 
 Layout/LineLength:
   Max: 160
+  Exclude:
+    - 'Gemfile'
 
 Layout/SpaceAroundEqualsInParameterDefault:
   EnforcedStyle: space
@@ -65,7 +67,7 @@ Metrics/BlockLength:
     - 'lib/legion/cli/mode_command.rb'
 
 Metrics/AbcSize:
-  Max: 60
+  Max: 62
   Exclude:
     - 'lib/legion/cli/chat_command.rb'
     - 'lib/legion/api/llm.rb'

data/CHANGELOG.md

@@ -2,6 +2,45 @@
 
 ## [Unreleased]
 
+## [1.7.12] - 2026-04-03
+
+### Fixed
+- Fixes #110: normal daemon boot now prefers library-owned LLM and Apollo API routes, `/api/tenants` uses canonical JSON parsing with correct status codes, SSE listeners drain worker threads on disconnect, paginated collections avoid unconditional `COUNT(*)` unless explicitly requested, and service startup skips duplicate settings loads once configuration is already bootstrapped
+
+## [1.7.11] - 2026-04-02
+
+### Fixed
+- Fixes #113: webhook deliveries now retry non-2xx responses and transport exceptions up to `max_retries`, record per-attempt delivery rows, dead-letter terminal failures, and cache active webhook pattern matching to reduce per-event dispatch overhead
+
+## [1.7.10] - 2026-04-02
+
+### Changed
+- Bumped minimum dependency floors for Legion core gems, including `legion-logging >= 1.5.0`, `legion-settings >= 1.3.25`, and updated transport, data, cache, crypt, Apollo, and MCP minimums
+- Stabilized the `LegionIO` spec suite by fixing the OAuth callback, catalog, and service shutdown regression specs
+- CLI startup now honors settings-driven log levels, normalizes `start --help` into the standard Thor help flow, and routes chat/error logging through the newer helper-backed logger path
+- `Legion::Service`, telemetry, and webhook runtime paths now use structured helper logging more consistently, respect configured logging when no CLI override is passed, and avoid brittle settings reads during boot
+- Extension runtime wiring now deep-dups merged settings, lazily registers the local `extension_catalog` migration, publishes catalog transitions directly to transport, and surfaces auto-binding failures more clearly
+- Secret, region, and task-outcome helpers now use canonical Vault connectivity checks, cache metadata misses more safely, and create meta-learning domains on demand before recording learning episodes
+
+## [1.7.8] - 2026-04-01
+
+### Added
+- `Legion::API::Settings` module with registered defaults via `merge_settings('api', ...)`, matching the pattern used by all other LegionIO gems
+- Puma `persistent_timeout` (20s) and `first_data_timeout` (30s) now configurable via `Settings[:api][:puma]`
+
+### Changed
+- Removed all inline `||` and `.fetch(..., default)` fallbacks for API settings in `service.rb` and `check_command.rb` — defaults now guaranteed by `merge_settings`
+
+## [1.7.7] - 2026-04-01
+
+### Changed
+- Integrated legion-logging 1.4.3 Helper refactor: all log output now uses structured segment tagging, colored exception output, and thread-local task context
+- Slimmed `Extensions::Helpers::Logger` to thin override; `derive_component_type`, `lex_gem_name`, `gem_spec_for_lex`, `log_lex_name` now live in legion-logging gem
+- Added `handle_runner_exception` for runner-specific exception handling (TaskLog publish + HandledTask raise)
+- Added `Legion::Context.with_task_context` and `.current_task_context` for thread-local task propagation
+- Wrapped all 5 dispatch paths (Runner.run, Subscription#dispatch_runner, Base#runner, Ingress local/remote) with context propagation
+- Migrated 13 `log.log_exception` call sites to `handle_exception` across actors, core, transport, and task helpers
+
 ## [1.7.6] - 2026-04-01
 
 ### Changed

data/legionio.gemspec

@@ -34,7 +34,7 @@ Gem::Specification.new do |spec|
   spec.bindir        = 'exe'
   spec.executables   = %w[legion legionio]
 
-  spec.add_dependency 'legion-mcp', '>= 0.5.1'
+  spec.add_dependency 'legion-mcp', '>= 0.7.1'
 
   spec.add_dependency 'kramdown', '>= 2.0'
 
@@ -52,15 +52,15 @@ Gem::Specification.new do |spec|
   spec.add_dependency 'thor', '>= 1.3'
   spec.add_dependency 'tty-spinner', '~> 0.9'
 
-  spec.add_dependency 'legion-cache', '>= 1.3.16'
-  spec.add_dependency 'legion-crypt', '>= 1.4.17'
-  spec.add_dependency 'legion-data', '>= 1.6.7'
+  spec.add_dependency 'legion-cache', '>= 1.3.21'
+  spec.add_dependency 'legion-crypt', '>= 1.5.0'
+  spec.add_dependency 'legion-data', '>= 1.6.19'
   spec.add_dependency 'legion-json', '>= 1.2.1'
-  spec.add_dependency 'legion-logging', '>= 1.4.0'
-  spec.add_dependency 'legion-settings', '>= 1.3.19'
-  spec.add_dependency 'legion-transport', '>= 1.4.4'
+  spec.add_dependency 'legion-logging', '>= 1.5.0'
+  spec.add_dependency 'legion-settings', '>= 1.3.25'
+  spec.add_dependency 'legion-transport', '>= 1.4.13'
 
-  spec.add_dependency 'legion-apollo', '>= 0.3.1'
+  spec.add_dependency 'legion-apollo', '>= 0.4.0'
   spec.add_dependency 'legion-gaia', '>= 0.9.26'
   spec.add_dependency 'legion-llm', '>= 0.5.8'
   spec.add_dependency 'legion-tty', '>= 0.4.35'

data/lib/legion/api/audit.rb

@@ -4,7 +4,7 @@ module Legion
   class API < Sinatra::Base
     module Routes
       module Audit
-        def self.registered(app) # rubocop:disable Metrics/AbcSize
+        def self.registered(app)
           app.get '/api/audit' do
             require_data!
             dataset = Legion::Data::Model::AuditLog.order(Sequel.desc(:id))

data/lib/legion/api/default_settings.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require 'sinatra/base'
+
+module Legion
+  class API < Sinatra::Base
+    module Settings
+      def self.default
+        {
+          enabled:         true,
+          port:            4567,
+          bind:            '0.0.0.0',
+          puma:            puma_defaults,
+          bind_retries:    3,
+          bind_retry_wait: 2,
+          tls:             tls_defaults
+        }
+      end
+
+      def self.puma_defaults
+        {
+          min_threads:        10,
+          max_threads:        16,
+          persistent_timeout: 20,
+          first_data_timeout: 30
+        }
+      end
+
+      def self.tls_defaults
+        {
+          enabled: false
+        }
+      end
+    end
+  end
+end
+
+begin
+  Legion::Settings.merge_settings('api', Legion::API::Settings.default) if Legion.const_defined?('Settings', false)
+rescue StandardError => e
+  if Legion.const_defined?('Logging', false) && Legion::Logging.respond_to?(:fatal)
+    Legion::Logging.fatal(e.message)
+    Legion::Logging.fatal(e.backtrace)
+  else
+    puts e.message
+    puts e.backtrace
+  end
+end

data/lib/legion/api/events.rb

@@ -5,6 +5,7 @@ module Legion
     module Routes
       module Events
         BUFFER_SIZE = 100
+        SSE_STOP = Object.new.freeze
 
         class << self
           def event_buffer
@@ -38,6 +39,42 @@ module Legion
             @listener_installed = true
           end
 
+          def write_sse_event(out, event)
+            payload = event.transform_keys(&:to_s)
+            out << "event: #{payload['event']}\ndata: #{Legion::JSON.dump(payload)}\n\n"
+          end
+
+          def stop_queue_stream(queue:, worker:, listener:)
+            Legion::Events.off('*', listener) if defined?(Legion::Events)
+            return unless worker&.alive?
+
+            queue.push(SSE_STOP)
+            worker.join(0.1)
+          rescue ThreadError, IOError, Errno::EPIPE => e
+            Legion::Logging.debug("Events SSE cleanup failed: #{e.message}") if defined?(Legion::Logging)
+          end
+
+          def stream_queue(out:, queue:, listener:)
+            worker = Thread.new do
+              loop do
+                event = queue.pop
+                break if event.equal?(SSE_STOP)
+
+                write_sse_event(out, event)
+              rescue IOError, Errno::EPIPE => e
+                Legion::Logging.debug("Events SSE stream broken for #{event[:event]}: #{e.message}") if defined?(Legion::Logging)
+                break
+              end
+            ensure
+              Legion::Events.off('*', listener) if defined?(Legion::Events)
+            end
+
+            cleanup = proc { stop_queue_stream(queue: queue, worker: worker, listener: listener) }
+            out.callback(&cleanup)
+            out.errback(&cleanup)
+            worker
+          end
+
           def registered(app)
             install_listener if defined?(Legion::Events)
 
@@ -53,21 +90,7 @@ module Legion
               end
 
               stream do |out|
-                Thread.new do
-                  loop do
-                    event = queue.pop
-                    data = Legion::JSON.dump(event.transform_keys(&:to_s))
-                    out << "event: #{event[:event]}\ndata: #{data}\n\n"
-                  rescue IOError, Errno::EPIPE => e
-                    Legion::Logging.debug "Events SSE stream broken for #{event[:event]}: #{e.message}" if defined?(Legion::Logging)
-                    break
-                  end
-                ensure
-                  Legion::Events.off('*', listener)
-                end
-
-                out.callback { Legion::Events.off('*', listener) }
-                out.errback { Legion::Events.off('*', listener) }
+                stream_queue(out: out, queue: queue, listener: listener)
               end
             end
 

data/lib/legion/api/helpers.rb

@@ -16,17 +16,20 @@ module Legion
         content_type :json
         status status_code
 
-        total = dataset.respond_to?(:count) ? dataset.count : dataset.length
         paginated = paginate(dataset)
-        items = paginated.respond_to?(:all) ? paginated.all : paginated
+        items = paginated.respond_to?(:all) ? paginated.all : Array(paginated)
+        total = collection_total(dataset, items)
+        meta = response_meta.merge(
+          count:  items.length,
+          limit:  page_limit,
+          offset: page_offset
+        )
+        meta[:total] = total unless total.nil?
+        meta[:has_more] = collection_has_more?(items, total)
 
         Legion::JSON.dump({
                             data: items.map { |r| r.respond_to?(:values) ? r.values : r },
-                            meta: response_meta.merge(
-                              total:  total,
-                              limit:  page_limit,
-                              offset: page_offset
-                            )
+                            meta: meta
                           })
       end
 
@@ -198,6 +201,25 @@ module Legion
           dataset
         end
       end
+
+      def include_total_count?
+        params[:include_total].to_s == 'true'
+      end
+
+      def collection_total(dataset, items)
+        return dataset.count if include_total_count? && dataset.respond_to?(:count)
+        return dataset.length if dataset.respond_to?(:length) && !dataset.respond_to?(:limit)
+
+        return page_offset + items.length if items.length < page_limit
+
+        nil
+      end
+
+      def collection_has_more?(items, total)
+        return (page_offset + items.length) < total if total
+
+        items.length == page_limit
+      end
     end
   end
 end

data/lib/legion/api/library_routes.rb

@@ -11,6 +11,9 @@ module Legion
     # @param gem_name [String] short name for the library (e.g. 'llm', 'apollo')
     # @param routes_module [Module] a Sinatra::Extension module to register
     def self.register_library_routes(gem_name, routes_module)
+      existing = router.library_routes[gem_name.to_s]
+      return routes_module if existing == routes_module
+
       router.register_library(gem_name, routes_module)
       register routes_module
     end

data/lib/legion/api/llm.rb

@@ -366,8 +366,11 @@ module Legion
               stream do |out|
                 full_text = +''
                 pipeline_response = executor.call_stream do |chunk|
-                  full_text << chunk
-                  out << "event: text-delta\ndata: #{Legion::JSON.dump({ delta: chunk })}\n\n"
+                  text = chunk.respond_to?(:content) ? chunk.content.to_s : chunk.to_s
+                  next if text.empty?
+
+                  full_text << text
+                  out << "event: text-delta\ndata: #{Legion::JSON.dump({ delta: text })}\n\n"
                 end
 
                 if pipeline_response.tools.is_a?(Array) && !pipeline_response.tools.empty?

data/lib/legion/api/tenants.rb

@@ -13,14 +13,13 @@ module Legion
           end
 
           app.post '/api/tenants' do
-            params = parsed_body
+            body = parse_request_body
             result = Legion::Tenants.create(
-              tenant_id:   params['tenant_id'],
-              name:        params['name'],
-              max_workers: params['max_workers'] || 10
+              tenant_id:   body[:tenant_id],
+              name:        body[:name],
+              max_workers: body[:max_workers] || 10
             )
-            status result[:error] ? 409 : 201
-            json_response(data: result)
+            json_response(result, status_code: result[:error] ? 409 : 201)
           end
 
           app.get '/api/tenants/:tenant_id' do

data/lib/legion/api/workers.rb

@@ -167,20 +167,7 @@ module Legion
               end
 
               stream do |out|
-                Thread.new do
-                  loop do
-                    event = queue.pop
-                    data = Legion::JSON.dump({ **event.transform_keys(&:to_s) })
-                    out << "event: #{event[:event]}\ndata: #{data}\n\n"
-                  rescue IOError, Errno::EPIPE
-                    break
-                  end
-                ensure
-                  Legion::Events.off('*', listener)
-                end
-
-                out.callback { Legion::Events.off('*', listener) }
-                out.errback { Legion::Events.off('*', listener) }
+                Routes::Events.stream_queue(out: out, queue: queue, listener: listener)
               end
             else
               count = (params[:count] || 25).to_i

data/lib/legion/api.rb

@@ -4,6 +4,7 @@ require 'sinatra/base'
 require 'legion/json'
 require_relative 'events'
 require_relative 'readiness'
+require_relative 'api/default_settings'
 
 require_relative 'api/middleware/auth'
 require_relative 'api/middleware/body_limit'
@@ -148,6 +149,25 @@ module Legion
       def router
         @router ||= Legion::API::Router.new
       end
+
+      def mount_library_routes(gem_name, fallback_module, preferred_constant_path)
+        preferred = constant_from_path(preferred_constant_path)
+        if preferred.is_a?(Module)
+          register_library_routes(gem_name, preferred)
+        elsif router.library_names.include?(gem_name)
+          register_library_routes(gem_name, router.library_routes.fetch(gem_name))
+        else
+          register fallback_module
+        end
+      end
+
+      private
+
+      def constant_from_path(path)
+        path.to_s.split('::').reject(&:empty?).reduce(Object) { |scope, name| scope.const_get(name) }
+      rescue NameError
+        nil
+      end
     end
 
     # Mount route modules
@@ -174,14 +194,14 @@ module Legion
     register Routes::Capacity
     register Routes::Audit
     register Routes::Metrics
-    register Routes::Llm unless router.library_names.include?('llm')
+    mount_library_routes('llm', Routes::Llm, 'Legion::LLM::Routes')
     register Routes::ExtensionCatalog
     register Routes::OrgChart
     register Routes::Governance
     register Routes::Acp
     register Routes::Prompts
     register Routes::Marketplace
-    register Routes::Apollo unless router.library_names.include?('apollo')
+    mount_library_routes('apollo', Routes::Apollo, 'Legion::Apollo::Routes')
     register Routes::Costs
     register Routes::Traces
     register Routes::Stats

data/lib/legion/cli/chat/chat_logger.rb

@@ -8,8 +8,14 @@ module Legion
   module CLI
     class Chat
       module ChatLogger
-        LOG_DIR  = File.expand_path('~/.legion')
+        LOG_DIR = File.expand_path('~/.legion')
         LOG_FILE = File.join(LOG_DIR, 'legion-chat.log')
+        LEVELS = {
+          'debug' => ::Logger::DEBUG,
+          'info'  => ::Logger::INFO,
+          'warn'  => ::Logger::WARN,
+          'error' => ::Logger::ERROR
+        }.freeze
 
         class << self
           attr_reader :logger
@@ -22,20 +28,21 @@ module Legion
             @logger
           end
 
-          def debug(msg)  = logger&.debug(msg)
-          def info(msg)   = logger&.info(msg)
-          def warn(msg)   = logger&.warn(msg)
-          def error(msg)  = logger&.error(msg)
+          def debug(msg) = logger&.debug(msg)
+
+          def info(msg) = logger&.info(msg)
+
+          def warn(msg) = logger&.warn(msg)
+
+          def error(msg) = logger&.error(msg)
 
           private
 
-          def parse_level(level)
-            case level.to_s
-            when 'debug' then ::Logger::DEBUG
-            when 'warn'  then ::Logger::WARN
-            when 'error' then ::Logger::ERROR
-            else ::Logger::INFO
-            end
+          def parse_level(level = 'info')
+            normalized_level = level.to_s.strip.downcase
+            return ::Logger::INFO if normalized_level.empty?
+
+            LEVELS.fetch(normalized_level, ::Logger::INFO)
           end
 
           def format_entry(severity, datetime, _progname, msg)

data/lib/legion/cli/check_command.rb

@@ -260,8 +260,10 @@ module Legion
 
         def check_api(_options)
           require 'legion/api'
-          port = (Legion::Settings[:api] || {})[:port] || 4567
-          bind = (Legion::Settings[:api] || {})[:bind] || '127.0.0.1'
+          api_settings = Legion::Settings[:api]
+          port = api_settings[:port]
+          configured_bind = api_settings[:bind]
+          bind = %w[127.0.0.1 localhost ::1].include?(configured_bind) ? configured_bind : '127.0.0.1'
 
           Legion::API.set :port, port
           Legion::API.set :bind, bind

data/lib/legion/cli/config_command.rb

@@ -101,7 +101,7 @@ module Legion
       end
 
       desc 'validate', 'Validate current configuration'
-      def validate # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity
+      def validate # rubocop:disable Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity
         out = formatter
         Connection.config_dir = options[:config_dir] if options[:config_dir]
 

data/lib/legion/cli/error_handler.rb

@@ -1,8 +1,12 @@
 # frozen_string_literal: true
 
+require 'legion/logging'
+
 module Legion
   module CLI
     module ErrorHandler
+      extend Legion::Logging::Helper
+
       PATTERNS = [
         {
           match:       /connection refused.*5672|ECONNREFUSED.*5672|bunny.*not connected/i,
@@ -71,11 +75,13 @@ module Legion
       def wrap(error)
         pattern = PATTERNS.find { |p| error.message.match?(p[:match]) }
         unless pattern
-          Legion::Logging.error("[CLI] unhandled error: #{error.class} — #{error.message}") if logging_available?
+          handle_exception(error, level: :error, handled: true, operation: :wrap_cli_error, matched: false) if logging_available?
+          log.error("[CLI] unhandled error: #{error.class} - #{error.message}") if logging_available?
           return error
         end
 
-        Legion::Logging.warn("[CLI] matched error pattern :#{pattern[:code]} — #{error.message}") if logging_available?
+        handle_exception(error, level: :warn, handled: true, operation: :wrap_cli_error, code: pattern[:code]) if logging_available?
+        log.warn("[CLI] matched error pattern :#{pattern[:code]} - #{error.message}") if logging_available?
         Error.actionable(
           code:        pattern[:code],
           message:     "#{pattern[:message]}: #{error.message}",

data/lib/legion/cli/start.rb

@@ -10,7 +10,7 @@ module Legion
             ENV['LEGION_LOCAL'] = 'true'
           end
 
-          log_level = options[:log_level] || 'info'
+          log_level = options[:log_level]
 
           # Load settings early, before any legion-* gem requires can trigger auto-load.
           # This ensures DNS bootstrap and config file loading happen exactly once.
@@ -26,7 +26,8 @@ module Legion
           clear_log_file unless options[:daemonize]
 
           api = options.fetch(:api, true)
-          service_opts = { log_level: log_level, api: api }
+          service_opts = { api: api }
+          service_opts[:log_level] = log_level if log_level
           service_opts[:http_port] = options[:http_port] if options[:http_port]
           service_opts[:role] = :lite if options[:lite]
           Legion.instance_variable_set(:@service, Legion::Service.new(**service_opts))

data/lib/legion/cli.rb

@@ -90,7 +90,7 @@ module Legion
       end
 
       def self.start(given_args = ARGV, config = {})
-        super
+        super(normalize_help_args(given_args), config)
       rescue Legion::CLI::Error => e
         Legion::Logging.error("CLI::Main.start CLI error: #{e.message}") if defined?(Legion::Logging)
         formatter = Output::Formatter.new(json: given_args.include?('--json'), color: !given_args.include?('--no-color'))
@@ -106,6 +106,17 @@ module Legion
         exit(1)
       end
 
+      def self.normalize_help_args(given_args)
+        args = Array(given_args).dup
+        return args unless args.length == 2
+        return args unless %w[--help -h].include?(args.last)
+
+        command = args.first
+        return args if command.start_with?('-') || command == 'help'
+
+        ['help', command]
+      end
+
       LEGION_GEMS = %w[
         legion-transport legion-cache legion-crypt legion-data
         legion-json legion-logging legion-settings
@@ -163,7 +174,7 @@ module Legion
       option :pidfile, type: :string, aliases: ['-p'], desc: 'PID file path'
       option :logfile, type: :string, aliases: ['-l'], desc: 'Log file path'
       option :time_limit, type: :numeric, aliases: ['-t'], desc: 'Run for N seconds then exit'
-      option :log_level, type: :string, default: 'info', desc: 'Log level (debug, info, warn, error)'
+      option :log_level, type: :string, desc: 'Log level (debug, info, warn, error)'
       option :api, type: :boolean, default: true, desc: 'Start the HTTP API server'
       option :http_port, type: :numeric, desc: 'HTTP API port (overrides settings)'
       option :lite, type: :boolean, default: false, desc: 'Start in lite mode (no external services)'

data/lib/legion/context.rb

@@ -51,6 +51,24 @@ module Legion
         Legion::Logging.debug "[Context] session cleared: #{ctx&.session_id}" if defined?(Legion::Logging)
         Thread.current[:legion_session_context] = nil
       end
+
+      def current_task_context
+        Thread.current[:legion_context]
+      end
+
+      def with_task_context(message)
+        previous = Thread.current[:legion_context]
+        Thread.current[:legion_context] = {
+          task_id:         message[:task_id],
+          conversation_id: message[:conversation_id],
+          chain_id:        message[:chain_id],
+          function:        message[:function],
+          runner_class:    message[:runner_class]
+        }.compact
+        yield
+      ensure
+        Thread.current[:legion_context] = previous
+      end
     end
   end
 end

data/lib/legion/extensions/actors/base.rb

@@ -16,9 +16,12 @@ module Legion
         define_dsl_accessor :remote_invocable, default: true
 
         def runner
-          Legion::Runner.run(runner_class: runner_class, function: function, check_subtask: check_subtask?, generate_task: generate_task?)
+          with_log_context(function) do
+            Legion::Runner.run(runner_class: runner_class, function: function,
+                               check_subtask: check_subtask?, generate_task: generate_task?)
+          end
         rescue StandardError => e
-          Legion::Logging.log_exception(e, component_type: :actor)
+          handle_exception(e)
         end
 
         def manual
@@ -31,7 +34,7 @@ module Legion
             klass.send(func, **args)
           end
         rescue StandardError => e
-          Legion::Logging.log_exception(e, component_type: :actor)
+          handle_exception(e)
         end
 
         def function

data/lib/legion/extensions/actors/every.rb

@@ -24,7 +24,8 @@ module Legion
                 log.debug "[Every] tick: #{self.class}" if defined?(log)
                 skip_or_run { use_runner? ? runner : manual }
               rescue StandardError => e
-                log.log_exception(e, payload_summary: "[Every] tick failed for #{self.class}", component_type: :actor) if defined?(log)
+                log.error "[Every] tick failed for #{self.class}: #{e.class}: #{e.message}" if defined?(log)
+                handle_exception(e) if defined?(log)
               ensure
                 @executing.make_false
               end
@@ -35,7 +36,7 @@ module Legion
 
           @timer.execute
         rescue StandardError => e
-          log.log_exception(e, component_type: :actor)
+          handle_exception(e)
         end
 
         def run_now?
@@ -52,7 +53,7 @@ module Legion
 
           @timer.shutdown
         rescue StandardError => e
-          log.log_exception(e, component_type: :actor)
+          handle_exception(e)
         end
       end
     end