legion-transport 1.4.21 → 1.4.23

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: aeafb67cb59afa83ee1e823350eb83453ad2987bc1d90daab781e3d9ab885bc7
-  data.tar.gz: 3ee0e275ee2fc819b69e8151d4caaa667dd505899232007a4149b7ffe3170004
+  metadata.gz: 264c545a4a225961456f42d8ca076d8cfe5a90967c4c80e44ea9aa14aaaee7df
+  data.tar.gz: 74d4e81af0e1da63558f6ee32988a3affd016a9bc13902ce6c28e4614249a70f
 SHA512:
-  metadata.gz: 4b108148e802a9578d5b4c27c03cd8148611d95ba9f48f5334cce8bed4007c037a8eba0e29bb5b4994f2242f3d0044ade06839adfc35b81ebe35f308f036ad82
-  data.tar.gz: 1a50340de99000d88dd90a05cd0216aeb5344838dc7274b6bc40d9aef37b6382c55ca6de9af03e81cd4805b175ea52fa6cf39e01411e0ca5acab1a744362463b
+  metadata.gz: 9611220c8d8b6395746ebefecbcd9b7558fe6dcb917c22b29c9bf17e9fc1dcc79fa7215e083f28c201b3b2f1ae746d5d3f2c8ae9ba8798f11e014edb83fe9f24
+  data.tar.gz: 307cc9c69ce19f240cb65272c6d0bb37030bd077c1ab511353ffb64fc7748480c927d4de4a714d16b1fe481878e7d1e0eca7df41eafde82eec80c64a4297668c

data/CHANGELOG.md

@@ -2,6 +2,30 @@
 
 ## [Unreleased]
 
+### Changed
+- Routes module now uses `extend Legion::Logging::Helper` with `log.*` and `handle_exception` instead of direct `Legion::Logging` calls
+
+### Removed
+- Unnecessary `defined?(Legion::Logging)` guards in routes.rb — legion-logging is a hard gemspec dependency
+- Unnecessary `defined?(Legion::Settings)` and `Legion.const_defined?('Settings')` guards in transport.rb, settings.rb, helper.rb, tenant_quota.rb, and tenant_topology.rb — legion-settings is a hard gemspec dependency
+
+## [1.4.23] - 2026-05-05
+
+### Added
+- `Message#publish` now supports live-request reliability options: `mandatory: true`, `publisher_confirm: true`, `publish_confirm_timeout_ms:`, `spool: false`, and structured publish results with `:accepted`, `:unroutable`, `:nacked`, `:confirm_timeout`, `:spooled`, or `:failed` status.
+- Structured publish result hash: `{ status:, accepted:, exchange:, routing_key:, message_id:, correlation_id:, return_reply_code:, return_reply_text: }` returned when any reliability option is active.
+- `reply_to:` field included in AMQP envelope options for RPC-style request/reply patterns.
+- `routing_key:` override in publish options allows callers to redirect a message at publish time without constructing a new message instance.
+- `persistent:` can now be overridden per-publish via options (previously only set at message construction).
+
+### Changed
+- `Message#publish` signature changed from `publish(options = @options)` to `publish(options = nil)` — passed options now **merge** with default `@options` instead of replacing them outright. Existing callers passing no arguments are unaffected.
+
+## [1.4.22] - 2026-04-24
+
+### Added
+- `x-legion-identity-trust` header on AMQP messages alongside existing `x-legion-identity-canonical-name`
+
 ## [1.4.21] - 2026-04-17
 
 ### Fixed

data/README.md

@@ -2,7 +2,7 @@
 
 Legion::Transport is the Ruby gem responsible for connecting LegionIO to its FIFO queue system (RabbitMQ over AMQP 0.9.1). It provides thread-safe connection management, exchange/queue abstractions, message publishing with optional encryption, and consumer wrappers.
 
-**Version**: 1.4.14
+**Version**: 1.4.23
 
 ## Features
 
@@ -13,6 +13,7 @@ Legion::Transport is the Ruby gem responsible for connecting LegionIO to its FIF
 - Dynamic credential retrieval from HashiCorp Vault
 - Auto-recovery on connection loss (configurable attempts, 5s shutdown timeout)
 - Dead letter exchange support
+- Reliable publish with publisher confirms, mandatory routing, and structured result reporting
 - Spool buffer for disk-backed message persistence when RabbitMQ is unavailable
 - `InProcess` adapter for lite mode (`LEGION_MODE=lite`): no RabbitMQ required, uses in-memory pub/sub
 - `Helper` mixin for LEX extensions: `transport_path`, `transport_class`, `messages`, `queues`, `exchanges`
@@ -66,6 +67,30 @@ Legion::Transport::Messages::Task.new(
 ).publish
 ```
 
+### Reliable Publish
+
+Pass reliability options to `#publish` to get structured feedback on message delivery:
+
+```ruby
+msg = Legion::Transport::Messages::Task.new(
+  function: 'process_order',
+  routing_key: 'orders.process',
+  correlation_id: SecureRandom.uuid
+)
+
+result = msg.publish(
+  mandatory: true,              # broker returns message if unroutable
+  publisher_confirm: true,      # wait for broker acknowledgment
+  publish_confirm_timeout_ms: 500, # confirm wait timeout
+  spool: false                  # disable disk spool on failure (fail fast)
+)
+
+result[:status]   # => :accepted, :unroutable, :nacked, :confirm_timeout, :spooled, or :failed
+result[:accepted] # => true/false
+```
+
+Options merge with the message's defaults — you can override `routing_key:` or `persistent:` per-publish without constructing a new message.
+
 ### Creating a Queue
 
 ```ruby

data/lib/legion/transport/errors.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require 'bunny/exceptions'
+
 module Legion
   module Transport
     class PoolTimeout < StandardError; end

data/lib/legion/transport/helper.rb

@@ -11,8 +11,6 @@ module Legion
       # Override in your LEX to set a custom default message TTL for the extension.
       # Resolution chain: per-call :ttl option -> LEX override -> Settings -> nil (no expiration)
       def transport_default_ttl
-        return nil unless defined?(Legion::Settings)
-
         Legion::Settings.dig(:transport, :messages, :ttl)
       rescue StandardError => e
         handle_exception(e, level: :warn, handled: true, operation: :transport_default_ttl)
@@ -58,8 +56,6 @@ module Legion
       # --- Status ---
 
       def transport_connected?
-        return false unless defined?(Legion::Settings)
-
         !!Legion::Settings.dig(:transport, :connected)
       rescue StandardError => e
         handle_exception(e, level: :warn, handled: true, operation: :transport_connected)

data/lib/legion/transport/kafka/consumer.rb

@@ -43,8 +43,8 @@ module Legion
                 commit_if_needed(consumer, count)
                 break if max_messages && count >= max_messages
               end
-            rescue StopIteration
-              # clean exit from consumer loop
+            rescue StopIteration => e
+              handle_exception(e, level: :warn, handled: true, operation: 'transport.kafka.consumer.loop_exit')
             ensure
               consumer.close
             end
@@ -178,7 +178,7 @@ module Legion
             result = consumer.offsets_for_times(offsets_for_times)
             result.to_h[topic]&.first&.last || 0
           rescue StandardError => e
-            handle_exception(e, level: :debug, handled: true, operation: 'transport.kafka.consumer.resolve_offset',
+            handle_exception(e, level: :warn, handled: true, operation: 'transport.kafka.consumer.resolve_offset',
                              topic: topic)
             0
           end

data/lib/legion/transport/kafka/incoming_message.rb

@@ -32,7 +32,7 @@ module Legion
 
           Legion::JSON.parse(@payload)
         rescue StandardError => e
-          handle_exception(e, level: :debug, handled: true, operation: 'transport.kafka.incoming_message.decoded_payload',
+          handle_exception(e, level: :warn, handled: true, operation: 'transport.kafka.incoming_message.decoded_payload',
                            topic: topic, offset: offset)
           @payload
         end

data/lib/legion/transport/kafka/producer.rb

@@ -29,7 +29,8 @@ module Legion
             report = delivery_handle.wait(max_wait_timeout: delivery_timeout)
             log_publish(topic, key, report)
             { topic: report.topic_name, partition: report.partition, offset: report.offset }
-          rescue Legion::Transport::Kafka::PublishError
+          rescue Legion::Transport::Kafka::PublishError => e
+            handle_exception(e, level: :error, handled: false, operation: 'transport.kafka.producer.publish')
             raise
           rescue StandardError => e
             handle_exception(e, level: :error, handled: false, operation: 'transport.kafka.producer.publish',
@@ -124,7 +125,7 @@ module Legion
 
             Legion::JSON.dump(payload)
           rescue StandardError => e
-            handle_exception(e, level: :debug, handled: true, operation: 'transport.kafka.producer.encode')
+            handle_exception(e, level: :warn, handled: true, operation: 'transport.kafka.producer.encode')
             payload.to_s
           end
 

data/lib/legion/transport/kafka.rb

@@ -40,7 +40,7 @@ module Legion
           require_rdkafka
           true
         rescue Legion::Transport::Kafka::UnavailableError => e
-          handle_exception(e, level: :debug, handled: true, operation: 'transport.kafka.enabled')
+          handle_exception(e, level: :warn, handled: true, operation: 'transport.kafka.enabled')
           false
         end
 
@@ -122,7 +122,7 @@ module Legion
         def kafka_settings
           Legion::Settings[:transport][:kafka]
         rescue StandardError => e
-          handle_exception(e, level: :debug, handled: true, operation: 'transport.kafka.settings')
+          handle_exception(e, level: :warn, handled: true, operation: 'transport.kafka.settings')
           Legion::Transport::Kafka::DEFAULTS
         end
 
@@ -143,7 +143,7 @@ module Legion
         def require_rdkafka
           require 'rdkafka'
         rescue LoadError => e
-          handle_exception(e, level: :debug, handled: true, operation: 'transport.kafka.require_rdkafka')
+          handle_exception(e, level: :warn, handled: true, operation: 'transport.kafka.require_rdkafka')
           raise Legion::Transport::Kafka::UnavailableError,
                 'rdkafka gem is required for Kafka support — add gem "rdkafka" to your Gemfile'
         end

data/lib/legion/transport/message.rb

@@ -23,9 +23,10 @@ module Legion
         1_048_576
       end
 
-      def publish(options = @options)
+      def publish(options = nil)
         raise unless @valid
 
+        publish_options = options ? @options.merge(options) : @options
         validate_payload_size
         ex_class = exchange
         exchange_dest = if ex_class.respond_to?(:cached_instance)
@@ -35,25 +36,132 @@ module Legion
                         else
                           ex_class
                         end
+        return_state = {}
+        install_return_listener(exchange_dest, publish_options, return_state)
+        prepare_publisher_confirms(exchange_dest, publish_options)
         exchange_dest.publish(encode_message,
-                              routing_key:      routing_key || '',
-                              content_type:     options[:content_type] || content_type,
-                              content_encoding: options[:content_encoding] || content_encoding,
-                              type:             options[:type] || type,
-                              priority:         options[:priority] || priority,
-                              expiration:       options[:expiration] || expiration,
-                              headers:          headers,
-                              persistent:       persistent,
-                              message_id:       message_id,
-                              correlation_id:   correlation_id,
-                              app_id:           app_id,
-                              timestamp:        timestamp)
-        ex_name = exchange_dest.respond_to?(:name) ? exchange_dest.name : exchange_dest.to_s
-        log.debug "Published to exchange=#{ex_name} routing_key=#{routing_key || ''} class=#{self.class.name}"
+                              **publish_envelope_options(publish_options))
+        result = publish_result(exchange_dest, publish_options, return_state)
+        return result if return_publish_result?(publish_options)
+
+        nil
       rescue Bunny::ConnectionClosedError, Bunny::ChannelAlreadyClosed, Bunny::ChannelError,
              Bunny::NetworkErrorWrapper, IOError, Timeout::Error => e
-        handle_exception(e, level: :warn, handled: true, operation: 'transport.message.publish', spooled: true)
-        spool_message(e)
+        handle_exception(e, level: :warn, handled: true, operation: 'transport.message.publish',
+                         spooled: spool_enabled?(publish_options))
+        spool_message(e, publish_options) if spool_enabled?(publish_options)
+        publish_failure_result(spool_enabled?(publish_options) ? :spooled : :failed, e, publish_options)
+      end
+
+      def publish_envelope_options(options)
+        {
+          routing_key:      options[:routing_key] || routing_key || '',
+          content_type:     options[:content_type] || content_type,
+          content_encoding: options[:content_encoding] || content_encoding,
+          type:             options[:type] || type,
+          priority:         options[:priority] || priority,
+          expiration:       options[:expiration] || expiration,
+          headers:          headers,
+          persistent:       options.key?(:persistent) ? options[:persistent] : persistent,
+          message_id:       message_id,
+          correlation_id:   correlation_id,
+          reply_to:         reply_to,
+          app_id:           app_id,
+          timestamp:        timestamp
+        }.tap do |envelope|
+          envelope[:mandatory] = true if options[:mandatory] == true
+        end
+      end
+
+      def publish_result(exchange_dest, options, return_state)
+        confirmed_status = confirm_publish(exchange_dest, options)
+        status = return_state[:returned] ? :unroutable : confirmed_status
+        ex_name = exchange_dest.respond_to?(:name) ? exchange_dest.name : exchange_dest.to_s
+        log.debug "Published to exchange=#{ex_name} routing_key=#{options[:routing_key] || routing_key || ''} class=#{self.class.name}"
+        {
+          status:            status,
+          accepted:          status == :accepted,
+          exchange:          ex_name,
+          routing_key:       options[:routing_key] || routing_key || '',
+          message_id:        message_id,
+          return_reply_code: return_state[:reply_code],
+          return_reply_text: return_state[:reply_text],
+          correlation_id:    correlation_id
+        }.compact
+      end
+
+      def prepare_publisher_confirms(exchange_dest, options)
+        return unless options[:publisher_confirm] == true
+
+        confirm_channel = publish_channel(exchange_dest)
+        return unless confirm_channel.respond_to?(:confirm_select)
+
+        confirm_channel.confirm_select
+      end
+
+      def confirm_publish(exchange_dest, options)
+        return :accepted unless options[:publisher_confirm] == true
+
+        confirm_channel = publish_channel(exchange_dest)
+        return :accepted unless confirm_channel.respond_to?(:wait_for_confirms)
+
+        timeout = options[:publish_confirm_timeout_ms]
+        confirmed = if timeout
+                      confirm_channel.wait_for_confirms(timeout.to_f / 1000.0)
+                    else
+                      confirm_channel.wait_for_confirms
+                    end
+        confirmed == false ? :nacked : :accepted
+      rescue Timeout::Error => e
+        handle_exception(e, level: :warn, handled: true, operation: 'transport.message.confirm_publish')
+        :confirm_timeout
+      end
+
+      def publish_channel(exchange_dest)
+        return exchange_dest.channel if exchange_dest.respond_to?(:channel)
+
+        channel
+      end
+
+      def install_return_listener(exchange_dest, options, return_state)
+        return unless options[:mandatory] == true
+
+        return_channel = publish_channel(exchange_dest)
+        return unless return_channel.respond_to?(:on_return)
+
+        expected_correlation_id = correlation_id
+        expected_message_id = message_id
+        return_channel.on_return do |return_info, properties, _content|
+          next if properties.respond_to?(:correlation_id) && properties.correlation_id &&
+                  expected_correlation_id && properties.correlation_id != expected_correlation_id
+          next if properties.respond_to?(:message_id) && properties.message_id &&
+                  expected_message_id && properties.message_id != expected_message_id
+
+          return_state[:returned] = true
+          return_state[:reply_code] = return_info.reply_code if return_info.respond_to?(:reply_code)
+          return_state[:reply_text] = return_info.reply_text if return_info.respond_to?(:reply_text)
+        end
+      end
+
+      def spool_enabled?(options)
+        options.fetch(:spool, true) != false
+      end
+
+      def return_publish_result?(options)
+        options[:return_result] == true || options[:mandatory] == true || options[:publisher_confirm] == true ||
+          options[:spool] == false
+      end
+
+      def publish_failure_result(status, error, options = @options)
+        {
+          status:         status,
+          accepted:       false,
+          error_class:    error.class.name,
+          error:          error.message,
+          routing_key:    options[:routing_key] || routing_key || '',
+          message_id:     message_id,
+          correlation_id: correlation_id
+        }
       end
 
       def app_id
@@ -220,6 +328,7 @@ module Legion
         id = Legion::Identity::Process.identity_hash
         {
           'x-legion-identity-canonical-name' => id[:canonical_name].to_s,
+          'x-legion-identity-trust'          => id[:trust].to_s,
           'x-legion-identity-id'             => id[:id].to_s,
           'x-legion-identity-kind'           => id[:kind].to_s,
           'x-legion-identity-mode'           => id[:mode].to_s,
@@ -265,18 +374,18 @@ module Legion
                                                 default_affinity
       end
 
-      def spool_message(error)
+      def spool_message(error, options = @options)
         return unless defined?(Legion::Transport::Spool)
 
         Legion::Transport::Spool.write(
           exchange:       exchange_name_for_spool,
-          routing_key:    routing_key || '',
+          routing_key:    options[:routing_key] || routing_key || '',
           payload:        message,
           headers:        @options[:headers],
           priority:       priority,
           message_id:     message_id,
           correlation_id: correlation_id,
-          persistent:     persistent
+          persistent:     options.key?(:persistent) ? options[:persistent] : persistent
         )
         log.info("Message spooled due to: #{error.message}")
       rescue StandardError => e

data/lib/legion/transport/routes.rb

@@ -7,9 +7,13 @@
 # LegionIO/lib/legion/api/transport.rb is preserved for backward compatibility but guards
 # its registration with defined?(Legion::Transport::Routes) so double-registration is avoided.
 
+require 'legion/logging/helper'
+
 module Legion
   module Transport
     module Routes
+      extend Legion::Logging::Helper
+
       def self.registered(app)
         register_helpers(app)
         register_status(app)
@@ -18,6 +22,7 @@ module Legion
       end
 
       def self.register_helpers(app)
+        app.helpers Legion::Logging::Helper
         register_json_helpers(app)
         register_transport_helpers(app)
       end
@@ -47,7 +52,8 @@ module Legion
 
               begin
                 parsed = Legion::JSON.load(raw)
-              rescue StandardError
+              rescue StandardError => e
+                handle_exception(e, level: :warn, handled: true, operation: :parse_request_body)
                 halt 400, { 'Content-Type' => 'application/json' },
                      Legion::JSON.dump({ error: { code: 'invalid_json', message: 'request body is not valid JSON' } })
               end
@@ -73,7 +79,7 @@ module Legion
                          .map { |klass| { name: klass.name } }
                          .sort_by { |h| h[:name].to_s }
             rescue NameError => e
-              Legion::Logging.debug "Transport routes: transport_subclasses failed for #{base_class}: #{e.message}" if defined?(Legion::Logging)
+              handle_exception(e, level: :warn, handled: true, operation: :transport_subclasses)
               []
             end
           end
@@ -85,19 +91,19 @@ module Legion
           connected = begin
             Legion::Settings[:transport][:connected]
           rescue StandardError => e
-            Legion::Logging.debug "Transport#status failed to read connected setting: #{e.message}" if defined?(Legion::Logging)
+            handle_exception(e, level: :warn, handled: true, operation: :transport_status_connected)
             false
           end
           session_open = begin
             Legion::Transport::Connection.session_open?
           rescue StandardError => e
-            Legion::Logging.debug "Transport#status failed to check session_open: #{e.message}" if defined?(Legion::Logging)
+            handle_exception(e, level: :warn, handled: true, operation: :transport_status_session_open)
             false
           end
           channel_open = begin
             Legion::Transport::Connection.channel_open?
           rescue StandardError => e
-            Legion::Logging.debug "Transport#status failed to check channel_open: #{e.message}" if defined?(Legion::Logging)
+            handle_exception(e, level: :warn, handled: true, operation: :transport_status_channel_open)
             false
           end
           connector = defined?(Legion::Transport::TYPE) ? Legion::Transport::TYPE.to_s : 'unknown'
@@ -121,14 +127,14 @@ module Legion
 
       def self.register_publish(app)
         app.post '/api/transport/publish' do
-          Legion::Logging.debug "API: POST /api/transport/publish params=#{params.keys}" if defined?(Legion::Logging)
+          log.debug "API: POST /api/transport/publish params=#{params.keys}"
           body = parse_request_body
           unless body[:exchange]
-            Legion::Logging.warn 'API POST /api/transport/publish returned 422: exchange is required' if defined?(Legion::Logging)
+            log.warn 'API POST /api/transport/publish returned 422: exchange is required'
             halt 422, json_error('missing_field', 'exchange is required', status_code: 422)
           end
           unless body[:routing_key]
-            Legion::Logging.warn 'API POST /api/transport/publish returned 422: routing_key is required' if defined?(Legion::Logging)
+            log.warn 'API POST /api/transport/publish returned 422: routing_key is required'
             halt 422, json_error('missing_field', 'routing_key is required', status_code: 422)
           end
 
@@ -136,10 +142,10 @@ module Legion
             exchange: body[:exchange], routing_key: body[:routing_key], **(body[:payload] || {})
           )
           message.publish
-          Legion::Logging.info "API: published message to exchange=#{body[:exchange]} routing_key=#{body[:routing_key]}" if defined?(Legion::Logging)
+          log.info "API: published message to exchange=#{body[:exchange]} routing_key=#{body[:routing_key]}"
           json_response({ published: true, exchange: body[:exchange], routing_key: body[:routing_key] }, status_code: 201)
         rescue StandardError => e
-          Legion::Logging.error "API POST /api/transport/publish: #{e.class} \u2014 #{e.message}" if defined?(Legion::Logging)
+          handle_exception(e, level: :error, handled: true, operation: :transport_publish)
           json_error('publish_error', e.message, status_code: 500)
         end
       end

data/lib/legion/transport/settings.rb

@@ -13,7 +13,7 @@ module Legion
         host = ENV['transport.connection.host'] || '127.0.0.1'
         port = (ENV['transport.connection.port'] || DEFAULT_AMQP_PORT).to_i
 
-        existing = defined?(Legion::Settings) ? (Legion::Settings[:transport][:connection] || {}) : {}
+        existing = Legion::Settings[:transport][:connection] || {}
         extra_server  = existing[:server]
         extra_servers = existing[:servers] || []
         extra_hosts   = existing[:hosts] || []
@@ -145,7 +145,7 @@ module Legion
 end
 
 begin
-  Legion::Settings.merge_settings('transport', Legion::Transport::Settings.default) if Legion.const_defined?('Settings')
+  Legion::Settings.merge_settings('transport', Legion::Transport::Settings.default)
 rescue StandardError => e
   Legion::Transport::Settings.handle_exception(e, level: :fatal, handled: true, operation: 'transport.settings.merge')
 end

data/lib/legion/transport/spool.rb

@@ -75,7 +75,7 @@ module Legion
             stream_lines(file) { n += 1 }
             n
           rescue StandardError => e
-            handle_exception(e, level: :debug, handled: true, operation: 'transport.spool.count', file: file)
+            handle_exception(e, level: :warn, handled: true, operation: 'transport.spool.count', file: file)
             0
           end
         end
@@ -90,7 +90,7 @@ module Legion
             File.delete(file)
             log.info "Evicted stale spool file=#{file}"
           rescue StandardError => e
-            handle_exception(e, level: :debug, handled: true, operation: 'transport.spool.evict_stale', file: file)
+            handle_exception(e, level: :warn, handled: true, operation: 'transport.spool.evict_stale', file: file)
             nil
           end
         end
@@ -138,7 +138,7 @@ module Legion
           total = files.sum do |f|
             File.size(f)
           rescue StandardError => e
-            handle_exception(e, level: :debug, handled: true, operation: 'transport.spool.over_limits', file: f)
+            handle_exception(e, level: :warn, handled: true, operation: 'transport.spool.over_limits', file: f)
             0
           end
           total >= @max_total_bytes
@@ -155,7 +155,7 @@ module Legion
               File.delete(oldest)
               log.info "Evicted oldest spool file=#{oldest}"
             rescue StandardError => e
-              handle_exception(e, level: :debug, handled: true, operation: 'transport.spool.evict_oldest')
+              handle_exception(e, level: :warn, handled: true, operation: 'transport.spool.evict_oldest')
               break
             end
           end
@@ -165,7 +165,7 @@ module Legion
           files.sum do |f|
             File.size(f)
           rescue StandardError => e
-            handle_exception(e, level: :debug, handled: true, operation: 'transport.spool.total_bytes', file: f)
+            handle_exception(e, level: :warn, handled: true, operation: 'transport.spool.total_bytes', file: f)
             0
           end
         end

data/lib/legion/transport/tenant_quota.rb

@@ -73,8 +73,6 @@ module Legion
         end
 
         def quota_settings(tenant_id)
-          return nil unless defined?(Legion::Settings)
-
           Legion::Settings.dig(:transport, :tenant_topology, :quotas, tenant_id.to_sym)
         rescue StandardError => e
           handle_exception(e, level: :warn, handled: true, operation: :tenant_quota_settings, tenant_id: tenant_id)

data/lib/legion/transport/tenant_topology.rb

@@ -46,8 +46,6 @@ module Legion
       end
 
       private_class_method def self.transport_settings
-        return {} unless defined?(Legion::Settings)
-
         Legion::Settings[:transport] || {}
       rescue StandardError => e
         handle_exception(e, level: :warn, handled: true, operation: :tenant_topology_transport_settings)

data/lib/legion/transport/version.rb

@@ -2,6 +2,6 @@
 
 module Legion
   module Transport
-    VERSION = '1.4.21'
+    VERSION = '1.4.23'
   end
 end

data/lib/legion/transport.rb

@@ -41,9 +41,7 @@ module Legion
       end
 
       def settings
-        return Legion::Settings[:transport] if Legion.const_defined?('Settings')
-
-        Legion::Transport::Settings.default
+        Legion::Settings[:transport]
       end
 
       private

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: legion-transport
 version: !ruby/object:Gem::Version
-  version: 1.4.21
+  version: 1.4.23
 platform: ruby
 authors:
 - Esity