legionio 1.7.6 → 1.7.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 30ac0f16cae1d42de41e7ed922e2fd75d96093017f7d562e2596b9c20bea99b6
-  data.tar.gz: 23fe67ca7f6171ea6e0ed13d50b382e78e1a7df4402cf1fe8174fcfea7d92ceb
+  metadata.gz: 6741515579e2c24f64b301136e023fb6ddd73b27f41779caace7df02cd15f667
+  data.tar.gz: c90f66af48bd6705b58c6c31344dd0a9486b8519cc48b98f3b1965d2571527db
 SHA512:
-  metadata.gz: ada4b04b1a274b66d60ab44ae9abe4b8ea998576d7d4a5b679ab3099ad91615924fe4646f671b544820d0b1db6e2bbcc0ceea84f2e5ed762e3f1321500017d99
-  data.tar.gz: b1a5d03f53e03039321f54529b0eae7abdc82462a20ee0dd0c1cb88927b15f606a07472b69cdeacc488217fc941d62074f83e567c09d3d26f21c821328309f14
+  metadata.gz: 5409680125318327c866c9f59dde8ce2b7b5a33cea5082bf2d654c763184c25e4658a24ef43d4b292f12546b314692da1b5d71ca6e25ca55e6095ea376d66d5f
+  data.tar.gz: 68a9358035224f600dfc673272d2cc82ecdfc7236a7225a2974721ad61b081571dbb190c77d25c8442bc3ff13c7cea44274b8331fd2942213a714167c56017c4

data/CHANGELOG.md

@@ -2,6 +2,25 @@
 
 ## [Unreleased]
 
+## [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/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/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.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'

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/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

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

@@ -13,7 +13,7 @@ module Legion
           @loop = true
           async.run
         rescue StandardError => e
-          Legion::Logging.log_exception(e, component_type: :actor)
+          handle_exception(e)
         end
 
         def run

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

@@ -27,7 +27,7 @@ check_subtask: check_subtask? }}"
               begin
                 skip_or_run { poll_cycle }
               rescue StandardError => e
-                Legion::Logging.log_exception(e, level: :fatal, component_type: :actor)
+                handle_exception(e, level: :fatal)
               ensure
                 @executing.make_false
               end
@@ -37,7 +37,7 @@ check_subtask: check_subtask? }}"
           end
           @timer.execute
         rescue StandardError => e
-          Legion::Logging.log_exception(e, component_type: :actor)
+          handle_exception(e)
         end
 
         def poll_cycle
@@ -69,7 +69,7 @@ check_subtask: check_subtask? }}"
           log.debug("#{self.class} result: #{results}")
           results
         rescue StandardError => e
-          Legion::Logging.log_exception(e, level: :fatal, component_type: :actor)
+          handle_exception(e, level: :fatal)
         end
 
         def cache_name
@@ -92,7 +92,7 @@ check_subtask: check_subtask? }}"
           Legion::Logging.debug 'Cancelling Legion Poller'
           @timer.shutdown
         rescue StandardError => e
-          Legion::Logging.log_exception(e, component_type: :actor)
+          handle_exception(e)
         end
       end
     end

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

@@ -25,7 +25,7 @@ module Legion
           @queue = queue.new
           @queue.channel.prefetch(prefetch) if defined? prefetch
         rescue StandardError => e
-          log.log_exception(e, level: :fatal, component_type: :actor)
+          handle_exception(e, level: :fatal)
         end
 
         def create_queue
@@ -83,12 +83,12 @@ module Legion
 
             cancel if Legion::Settings[:client][:shutting_down]
           rescue StandardError => e
-            log.log_exception(e, payload_summary: "[Subscription] message processing failed: #{lex_name}/#{fn}", component_type: :actor)
+            handle_exception(e, lex: lex_name, fn: fn, routing_key: delivery_info.routing_key)
             @queue.reject(delivery_info.delivery_tag) if manual_ack
           end
           log.info "[Subscription] prepared: #{lex_name}/#{runner_name}"
         rescue StandardError => e
-          log.log_exception(e, level: :fatal, payload_summary: 'Subscription#prepare failed', component_type: :actor)
+          handle_exception(e, level: :fatal)
         end
 
         def activate
@@ -175,7 +175,7 @@ module Legion
 
             cancel if Legion::Settings[:client][:shutting_down]
           rescue StandardError => e
-            log.log_exception(e, payload_summary: "[Subscription] message processing failed: #{lex_name}/#{fn}", component_type: :actor)
+            handle_exception(e)
             log.warn "[Subscription] nacking message for #{lex_name}/#{fn}"
             @queue.reject(delivery_info.delivery_tag) if manual_ack
           end
@@ -207,11 +207,14 @@ module Legion
 
         def dispatch_runner(message, runner_cls, function, check_subtask, generate_task)
           run_block = lambda {
-            Legion::Runner.run(**message,
-                               runner_class:  runner_cls,
-                               function:      function,
-                               check_subtask: check_subtask,
-                               generate_task: generate_task)
+            ctx = message.merge(runner_class: runner_cls.to_s, function: function.to_s)
+            Legion::Context.with_task_context(ctx) do
+              Legion::Runner.run(**message,
+                                 runner_class:  runner_cls,
+                                 function:      function,
+                                 check_subtask: check_subtask,
+                                 generate_task: generate_task)
+            end
           }
 
           if defined?(Legion::Telemetry::OpenInference)

data/lib/legion/extensions/core.rb

@@ -235,7 +235,7 @@ module Legion
           lex_class.const_set(:Data, Module.new { extend Legion::Extensions::Data })
         end
       rescue StandardError => e
-        log.log_exception(e, payload_summary: "[Core] auto_generate_data failed for #{name}", component_type: :builder)
+        handle_exception(e, lex: lex_name, operation: 'auto_generate_data')
       end
     end
   end

data/lib/legion/extensions/helpers/logger.rb

@@ -9,78 +9,19 @@ module Legion
         include Legion::Extensions::Helpers::Base
         include Legion::Logging::Helper
 
-        def handle_exception(exception, task_id: nil, **opts)
-          spec = gem_spec_for_lex
-          log.log_exception(exception,
-                            lex:             log_lex_name,
-                            component_type:  derive_component_type,
-                            gem_name:        lex_gem_name,
-                            lex_version:     spec&.version&.to_s,
-                            gem_path:        spec&.full_gem_path,
-                            source_code_uri: spec&.metadata&.[]('source_code_uri'),
-                            handled:         true,
-                            payload_summary: opts.empty? ? nil : opts,
-                            task_id:         task_id)
+        def handle_runner_exception(exception, task_id: nil, **opts) # rubocop:disable Style/ArgumentsForwarding
+          handle_exception(exception, task_id: task_id, **opts) # rubocop:disable Style/ArgumentsForwarding
 
           unless task_id.nil?
             Legion::Transport::Messages::TaskLog.new(
               task_id:      task_id,
               runner_class: to_s,
-              entry:        {
-                exception: true,
-                message:   exception.message,
-                **opts
-              }
+              entry:        { exception: true, message: exception.message, **opts }
             ).publish
           end
 
           raise Legion::Exception::HandledTask
         end
-
-        private
-
-        def derive_component_type
-          parts = respond_to?(:calling_class_array) ? calling_class_array : self.class.to_s.split('::')
-          match = parts.find { |p| Legion::Extensions::Helpers::Base::NAMESPACE_BOUNDARIES.include?(p) }
-          case match
-          when 'Runners'          then :runner
-          when 'Actor', 'Actors'  then :actor
-          when 'Transport'        then :transport
-          when 'Helpers'          then :helper
-          when 'Data'             then :data
-          else :unknown
-          end
-        rescue StandardError
-          :unknown
-        end
-
-        def lex_gem_name
-          base_name = log_lex_name
-          return nil unless base_name
-
-          "lex-#{base_name}"
-        rescue StandardError
-          nil
-        end
-
-        def gem_spec_for_lex
-          name = lex_gem_name
-          return nil unless name
-
-          Gem::Specification.find_by_name(name)
-        rescue Gem::MissingSpecError
-          nil
-        end
-
-        def log_lex_name
-          if respond_to?(:segments)
-            segments.join('-')
-          else
-            derive_log_tag
-          end
-        rescue StandardError
-          nil
-        end
       end
     end
   end

data/lib/legion/extensions/helpers/task.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative 'base'
+require_relative 'logger'
 require 'legion/transport'
 require 'legion/transport/messages/task_update'
 require 'legion/transport/messages/task_log'
@@ -10,6 +11,7 @@ module Legion
     module Helpers
       module Task
         include Legion::Extensions::Helpers::Base
+        include Legion::Extensions::Helpers::Logger
 
         def generate_task_log(task_id:, function:, runner_class: to_s, **payload)
           begin
@@ -19,7 +21,7 @@ module Legion
               return true if Legion::Data::Model::TaskLog.insert(task_id: task_id, function_id: function_id, entry: Legion::JSON.dump(payload))
             end
           rescue StandardError => e
-            log.log_exception(e, level: :warn, payload_summary: 'generate_task_log failed, reverting to rmq message', component_type: :helper)
+            handle_exception(e, level: :warn)
           end
           Legion::Transport::Messages::TaskLog.new(task_id: task_id, runner_class: runner_class, function: function, entry: payload).publish
         end
@@ -43,7 +45,7 @@ module Legion
           end
           Legion::Transport::Messages::TaskUpdate.new(**update_hash).publish
         rescue StandardError => e
-          log.log_exception(e, level: :fatal, component_type: :helper)
+          handle_exception(e, level: :fatal)
           raise e
         end
 

data/lib/legion/extensions/transport.rb

@@ -25,7 +25,8 @@ module Legion
         auto_generate_messages
         log.info "[Transport] built exchanges=#{@exchanges.count} queues=#{@queues.count} for #{lex_name}"
       rescue StandardError => e
-        log.log_exception(e, payload_summary: "[Transport] build failed for #{lex_name}", component_type: :transport)
+        log.error "[Transport] build failed for #{lex_name}"
+        handle_exception(e, lex: lex_name)
       end
 
       def generate_base_modules
@@ -175,7 +176,7 @@ module Legion
         to = to.is_a?(String) ? Kernel.const_get(to).new : to.new
         to.bind(from, routing_key: routing_key)
       rescue StandardError => e
-        log.log_exception(e, level: :fatal, payload_summary: { from: from, to: to, routing_key: routing_key }, component_type: :transport)
+        handle_exception(e, level: :fatal, from: from, to: to, routing_key: routing_key)
       end
 
       def e_to_q

data/lib/legion/ingress.rb

@@ -82,17 +82,21 @@ module Legion
         if local_runner?(rc)
           Legion::Logging.debug "[Ingress] local short-circuit: #{rc}.#{fn}" if defined?(Legion::Logging)
           klass = rc.is_a?(String) ? Kernel.const_get(rc) : rc
-          return klass.send(fn.to_sym, **message)
+          ctx = message.merge(runner_class: rc.to_s, function: fn.to_s)
+          return Legion::Context.with_task_context(ctx) { klass.send(fn.to_sym, **message) }
         end
 
         runner_block = lambda {
-          Legion::Runner.run(
-            runner_class:  rc,
-            function:      fn,
-            check_subtask: check_subtask,
-            generate_task: generate_task,
-            **message
-          )
+          ctx = message.merge(runner_class: rc.to_s, function: fn.to_s)
+          Legion::Context.with_task_context(ctx) do
+            Legion::Runner.run(
+              runner_class:  rc,
+              function:      fn,
+              check_subtask: check_subtask,
+              generate_task: generate_task,
+              **message
+            )
+          end
         }
 
         if defined?(Legion::Telemetry::OpenInference)

data/lib/legion/runner.rb

@@ -2,12 +2,13 @@
 
 require_relative 'runner/log'
 require_relative 'runner/status'
+require_relative 'context'
 require 'legion/transport'
 require 'legion/transport/messages/check_subtask'
 
 module Legion
   module Runner
-    def self.run(runner_class:, function:, task_id: nil, args: nil, check_subtask: true, generate_task: true, parent_id: nil, master_id: nil, catch_exceptions: false, **opts) # rubocop:disable Layout/LineLength, Metrics/CyclomaticComplexity, Metrics/ParameterLists, Metrics/MethodLength, Metrics/PerceivedComplexity
+    def self.run(runner_class:, function:, task_id: nil, args: nil, check_subtask: true, generate_task: true, parent_id: nil, master_id: nil, catch_exceptions: false, **opts) # rubocop:disable Layout/LineLength, Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/ParameterLists, Metrics/MethodLength, Metrics/PerceivedComplexity
       started_at = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
       lex_tag = derive_lex_tag(runner_class)
       rlog = runner_logger(lex_tag)
@@ -31,24 +32,38 @@ module Legion
       # result = Fiber.new { Fiber.yield runner_class.send(function, **args) }
       raise 'No Function defined' if function.nil?
 
-      result = runner_class.send(function, **args)
-    rescue Legion::Exception::HandledTask => e
-      rlog.debug "[Runner] HandledTask raised in #{runner_class}##{function}: #{e.message}"
-      status = 'task.exception'
-      result = { error: {} }
-    rescue StandardError => e
-      rlog.error "[Runner] exception in #{runner_class}##{function}: #{e.message}"
-      status = 'task.exception'
-      result = { success: false, status: status, error: { message: e.message, backtrace: e.backtrace } }
-      runner_class.handle_exception(e,
-                                    **opts,
-                                    runner_class:  runner_class,
-                                    args:          args,
-                                    function:      function,
-                                    task_id:       task_id,
-                                    generate_task: generate_task,
-                                    check_subtask: check_subtask)
-      raise e unless catch_exceptions
+      result = nil
+      status = nil
+      Legion::Context.with_task_context(opts.merge(task_id: task_id, function: function, runner_class: runner_class.to_s)) do
+        result = if runner_class.respond_to?(:with_log_context)
+                   runner_class.with_log_context(function) { runner_class.send(function, **args) }
+                 else
+                   runner_class.send(function, **args)
+                 end
+      rescue Legion::Exception::HandledTask => e
+        rlog.debug "[Runner] HandledTask raised in #{runner_class}##{function}: #{e.message}"
+        status = 'task.exception'
+        result = { error: {} }
+      rescue StandardError => e
+        rlog.error "[Runner] exception in #{runner_class}##{function}: #{e.message}"
+        status = 'task.exception'
+        result = { success: false, status: status, error: { message: e.message, backtrace: e.backtrace } }
+        if runner_class.respond_to?(:handle_runner_exception)
+          begin
+            runner_class.handle_runner_exception(e,
+                                                 **opts,
+                                                 runner_class:  runner_class,
+                                                 args:          args,
+                                                 function:      function,
+                                                 task_id:       task_id,
+                                                 generate_task: generate_task,
+                                                 check_subtask: check_subtask)
+          rescue Legion::Exception::HandledTask => handled
+            rlog.debug "[Runner] HandledTask raised while handling exception in #{runner_class}##{function}: #{handled.message}"
+          end
+        end
+        raise e unless catch_exceptions
+      end
     ensure
       status = 'task.completed' if status.nil?
       duration_ms = ((::Process.clock_gettime(::Process::CLOCK_MONOTONIC) - started_at) * 1000).round

data/lib/legion/service.rb

@@ -142,8 +142,10 @@ module Legion
       setup_metrics
       setup_task_outcome_observer
 
-      api_settings = Legion::Settings[:api] || {}
-      @api_enabled = api && api_settings.fetch(:enabled, true)
+      require 'sinatra/base'
+      require 'legion/api/default_settings'
+      api_settings = Legion::Settings[:api]
+      @api_enabled = api && api_settings[:enabled]
       setup_api if @api_enabled
       setup_network_watchdog
       Legion::Settings[:client][:ready] = true
@@ -264,38 +266,48 @@ module Legion
       )
     end
 
-    def setup_api
+    def setup_api # rubocop:disable Metrics/MethodLength
       if @api_thread&.alive?
         Legion::Logging.warn 'API already running, skipping duplicate setup_api call'
         return
       end
 
       require 'legion/api'
-      api_settings = Legion::Settings[:api] || {}
-      port = api_settings[:port] || 4567
-      bind = api_settings[:bind] || '0.0.0.0'
+      api_settings = Legion::Settings[:api]
+      port = api_settings[:port]
+      bind = api_settings[:bind]
 
       Legion::API.set :port, port
       Legion::API.set :bind, bind
       Legion::API.set :server, :puma
       Legion::API.set :environment, :production
 
+      puma_cfg    = api_settings[:puma]
+      min_threads = puma_cfg[:min_threads]
+      max_threads = puma_cfg[:max_threads]
+      thread_spec = "#{min_threads}:#{max_threads}"
+      puma_timeouts = {
+        persistent_timeout: puma_cfg[:persistent_timeout],
+        first_data_timeout: puma_cfg[:first_data_timeout]
+      }.compact
+
       tls_cfg = build_api_tls_config(api_settings)
       if tls_cfg
         Legion::API.set :ssl_bind_options, tls_cfg
-        Legion::API.set :server_settings, { quiet: true, **ssl_server_settings(tls_cfg, bind, port) }
+        Legion::API.set :server_settings, { quiet: true, Threads: thread_spec, **puma_timeouts,
+                                            **ssl_server_settings(tls_cfg, bind, port) }
         Legion::Logging.info "Starting Legion API (TLS) on #{bind}:#{port}"
       else
         require 'puma'
         puma_log = ::Puma::LogWriter.new(StringIO.new, StringIO.new)
-        Legion::API.set :server_settings, { log_writer: puma_log, quiet: true }
+        Legion::API.set :server_settings, { log_writer: puma_log, quiet: true, Threads: thread_spec, **puma_timeouts }
         Legion::Logging.info "Starting Legion API on #{bind}:#{port}"
       end
 
       @api_thread = Thread.new do
         retries = 0
-        max_retries = api_settings.fetch(:bind_retries, 3)
-        retry_wait  = api_settings.fetch(:bind_retry_wait, 2)
+        max_retries = api_settings[:bind_retries]
+        retry_wait  = api_settings[:bind_retry_wait]
 
         begin
           raise Errno::EADDRINUSE, "port #{port} already bound" if port_in_use?(bind, port)

data/lib/legion/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: legionio
 version: !ruby/object:Gem::Version
-  version: 1.7.6
+  version: 1.7.8
 platform: ruby
 authors:
 - Esity
@@ -472,6 +472,7 @@ files:
 - lib/legion/api/codegen.rb
 - lib/legion/api/coldstart.rb
 - lib/legion/api/costs.rb
+- lib/legion/api/default_settings.rb
 - lib/legion/api/events.rb
 - lib/legion/api/extensions.rb
 - lib/legion/api/gaia.rb