legionio 1.7.13 → 1.7.15

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 42d28272b4f314a736fdd339106511ef743107d7df2b1a771d403a8312d66135
-  data.tar.gz: aa616bda3a27ae36e9524a5dcdc4f027d730274cd04f4e45a1142accc638365c
+  metadata.gz: de3b6cd94efb3c63cc92dfcd54303a89fa9517b9a525349b2a40750373e6cb2f
+  data.tar.gz: 8cbee81b7503b87a10502b47b308d614e1c22a2675f881c110c9cc8b753561c5
 SHA512:
-  metadata.gz: e1b1d5265860f317faf0da4a23e5e25373e290e4b4456acc0ceffdd3b6f3b8f65f97a5d78c0ca199f7882ab1776e9a17cc585a11dd8eb3ac8f75d6b9ef4b7772
-  data.tar.gz: bd82d4424862d625639be08c340686b0eb830f1cd4002116c69dd525116576685761c0624b6dddfa19a789b6c98561444a88c89e8a8a002a846c3ca01494aa8a
+  metadata.gz: bbaa15bc0e0c87a1f72bc8efc84f005e6a1f6b02bb56464436e7cc3d80ec67a9f691107561b3a817d2bb63b5be0f3c0c2b081a5595a491daa29db5328bffb2f2
+  data.tar.gz: af119a4f87785f6bc2f05b2c01977e7d352882f20fb1407b6aef7e3ed08f1d96ab5c37f8814f6bd7eb403b554cd9cfb7ea0aa71e46509703e3d34dfe6f6ced2a

data/CHANGELOG.md

@@ -2,6 +2,23 @@
 
 ## [Unreleased]
 
+## [1.7.15] - 2026-04-03
+
+### Added
+- Every actors now support `delay` method to defer timer start (used by lex-microsoft_teams)
+- Request logger emits `[api][request-start]` on inbound, warns on responses > 5s
+
+### Changed
+- `/api/reload` disabled (returns 418) to prevent accidental full-restart loops
+
+## [1.7.14] - 2026-04-03
+
+### Fixed
+- Actor boot ordering: once → poll → every → loop → subscriptions, preventing timer actors from competing with AMQP channel setup
+- Builder now respects `remote_invocable? false` and skips auto-generated subscription actors for local-only extensions
+- Catalog exchange cached and reused instead of creating a new channel + exchange_declare per transition
+- Catalog SQLite persists batched into a single transaction at end of boot instead of per-transition writes from concurrent threads
+
 ## [1.7.13] - 2026-04-03
 
 ### Changed

data/lib/legion/api/middleware/request_logger.rb

@@ -9,15 +9,18 @@ module Legion
         end
 
         def call(env)
+          method_path = "#{env['REQUEST_METHOD']} #{env['PATH_INFO']}"
+          Legion::Logging.info "[api][request-start] #{method_path}"
           start = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
           status, headers, body = @app.call(env)
           duration = ((::Process.clock_gettime(::Process::CLOCK_MONOTONIC) - start) * 1000).round(2)
 
-          Legion::Logging.info "[api] #{env['REQUEST_METHOD']} #{env['PATH_INFO']} #{status} #{duration}ms"
+          level = duration > 5000 ? :warn : :info
+          Legion::Logging.send(level, "[api] #{method_path} #{status} #{duration}ms")
           [status, headers, body]
         rescue StandardError => e
           duration = ((::Process.clock_gettime(::Process::CLOCK_MONOTONIC) - start) * 1000).round(2)
-          Legion::Logging.error "[api] #{env['REQUEST_METHOD']} #{env['PATH_INFO']} 500 #{duration}ms - #{e.message}"
+          Legion::Logging.error "[api] #{method_path} 500 #{duration}ms - #{e.message}"
           raise
         end
       end

data/lib/legion/api.rb

@@ -111,8 +111,9 @@ module Legion
     end
 
     post '/api/reload' do
-      Thread.new { Legion.reload }
-      json_response({ status: 'reloading' })
+      log.error "[api] reload attempted by #{request.ip} — blocked"
+      halt 418, { 'Content-Type' => 'application/json' },
+           Legion::JSON.dump({ error: 'reload is disabled', status: 418 })
     end
 
     # Global error handlers

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

@@ -34,7 +34,12 @@ module Legion
             end
           end
 
-          @timer.execute
+          initial_delay = respond_to?(:delay) ? delay.to_f : 0
+          if initial_delay.positive?
+            Concurrent::ScheduledTask.execute(initial_delay) { @timer.execute }
+          else
+            @timer.execute
+          end
         rescue StandardError => e
           handle_exception(e)
         end

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

@@ -37,6 +37,11 @@ module Legion
         end
 
         def build_meta_actor_list
+          if lex_class.respond_to?(:remote_invocable?) && !lex_class.remote_invocable?
+            log.debug "[Actors] skipping meta actors for #{lex_class} (remote_invocable=false)"
+            return
+          end
+
           @runners.each do |runner, attr|
             next if @actors[runner.to_sym].is_a? Hash
 

data/lib/legion/extensions/catalog.rb

@@ -61,6 +61,40 @@ module Legion
           @warned_missing_extension_catalog = false
         end
 
+        def flush_persisted_transitions
+          pending = nil
+          @pending_persists_mutex ||= Mutex.new
+          @pending_persists_mutex.synchronize do
+            return if @pending_persists.nil? || @pending_persists.empty?
+
+            pending = @pending_persists.dup
+            @pending_persists.clear
+          end
+
+          return unless defined?(Legion::Data::Local) &&
+                        Legion::Data::Local.respond_to?(:connected?) &&
+                        Legion::Data::Local.connected?
+
+          ensure_local_migration_registered!
+          return warn_missing_extension_catalog_once unless extension_catalog_table_available?
+
+          model = Legion::Data::Local.model(:extension_catalog)
+          now = Time.now
+          Legion::Data::Local.connection.transaction do
+            pending.each do |lex_name, new_state|
+              existing = model.where(lex_name: lex_name).first
+              if existing
+                existing.update(state: new_state.to_s, updated_at: now)
+              else
+                model.insert(lex_name: lex_name, state: new_state.to_s, created_at: now, updated_at: now)
+              end
+            end
+          end
+          Legion::Logging.info "Catalog persisted #{pending.size} transitions" if defined?(Legion::Logging)
+        rescue StandardError => e
+          Legion::Logging.warn { "Catalog flush failed: #{e.class}: #{e.message}" } if defined?(Legion::Logging)
+        end
+
         private
 
         def entries
@@ -78,30 +112,25 @@ module Legion
             timestamp: Time.now.to_i
           )
 
-          exchange = Legion::Transport::Exchange.new('legion.catalog')
-          exchange.publish(payload, routing_key: "legion.catalog.#{lex_name}.#{new_state}",
-                                    content_type: 'application/json', persistent: true)
+          catalog_exchange.publish(payload, routing_key: "legion.catalog.#{lex_name}.#{new_state}",
+                                            content_type: 'application/json', persistent: true)
         rescue StandardError => e
+          @catalog_exchange = nil
           Legion::Logging.warn { "Catalog publish failed for #{lex_name}=#{new_state}: #{e.class}: #{e.message}" } if defined?(Legion::Logging)
         end
 
-        def persist_transition(lex_name, new_state)
-          return unless defined?(Legion::Data::Local) &&
-                        Legion::Data::Local.respond_to?(:connected?) &&
-                        Legion::Data::Local.connected?
+        def catalog_exchange
+          return @catalog_exchange if @catalog_exchange&.channel&.open?
 
-          ensure_local_migration_registered!
-          return warn_missing_extension_catalog_once unless extension_catalog_table_available?
+          @catalog_exchange = Legion::Transport::Exchange.new('legion.catalog')
+        end
 
-          model = Legion::Data::Local.model(:extension_catalog)
-          existing = model.where(lex_name: lex_name).first
-          if existing
-            existing.update(state: new_state.to_s, updated_at: Time.now)
-          else
-            model.insert(lex_name: lex_name, state: new_state.to_s, created_at: Time.now, updated_at: Time.now)
+        def persist_transition(lex_name, new_state)
+          @pending_persists_mutex ||= Mutex.new
+          @pending_persists_mutex.synchronize do
+            @pending_persists ||= {}
+            @pending_persists[lex_name] = new_state
           end
-        rescue StandardError => e
-          Legion::Logging.warn { "Catalog persist failed for #{lex_name}=#{new_state}: #{e.class}: #{e.message}" } if defined?(Legion::Logging)
         end
 
         def extension_catalog_table_available?

data/lib/legion/extensions.rb

@@ -279,16 +279,18 @@ module Legion
 
         Legion::Logging.info "Hooking #{@pending_actors.size} deferred actors"
 
-        sub_actors = []
-        @pending_actors.each do |actor|
-          if actor[:actor_class].ancestors.include?(Legion::Extensions::Actors::Subscription)
-            sub_actors << actor
-          else
-            hook_actor(**actor)
-          end
-        end
+        groups = group_pending_actors
 
-        hook_subscription_actors_pooled(sub_actors) unless sub_actors.empty?
+        %i[once poll every loop].each do |type|
+          next if groups[type].empty?
+
+          Legion::Logging.info "Starting #{type} actors (#{groups[type].size})"
+          groups[type].each { |actor| hook_actor(**actor) }
+        end
+        unless groups[:subscription].empty?
+          Legion::Logging.info "Starting subscription actors (#{groups[:subscription].size})"
+          hook_subscription_actors_pooled(groups[:subscription])
+        end
         dispatch_local_actors(@local_tasks) unless @local_tasks.empty?
 
         @pending_actors.clear
@@ -301,6 +303,33 @@ module Legion
           "local:#{@local_tasks.count}"
         )
         @loaded_extensions&.each { |name| Catalog.transition(name, :running) }
+        Catalog.flush_persisted_transitions
+      end
+
+      ACTOR_TYPE_MAP = {
+        Once:         :once,
+        Poll:         :poll,
+        Every:        :every,
+        Loop:         :loop,
+        Subscription: :subscription
+      }.freeze
+
+      def group_pending_actors
+        groups = { once: [], poll: [], every: [], loop: [], subscription: [] }
+        @pending_actors.each do |actor|
+          type = resolve_actor_type(actor[:actor_class])
+          groups[type] << actor
+        end
+        groups
+      end
+
+      def resolve_actor_type(actor_class)
+        anc = actor_class.ancestors
+        ACTOR_TYPE_MAP.each do |const, type|
+          return type if anc.include?(Legion::Extensions::Actors.const_get(const))
+        end
+        Legion::Logging.warn "Unknown actor type for #{actor_class}, defaulting to loop"
+        :loop
       end
 
       def hook_actor(extension:, extension_name:, actor_class:, size: 1, **opts)

data/lib/legion/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: legionio
 version: !ruby/object:Gem::Version
-  version: 1.7.13
+  version: 1.7.15
 platform: ruby
 authors:
 - Esity