legion-logging 1.5.5 → 1.5.19

data/lib/legion/logging/methods.rb

@@ -1,16 +1,19 @@
 # frozen_string_literal: true
 
 require 'securerandom'
+require_relative 'header_builder'
 
 module Legion
   module Logging
     module Methods
+      include Legion::Logging::HeaderBuilder
+
       COMPONENT_REGEX = %r{
         /(runners|actors|actor|helpers|hooks|absorbers|matchers|transport|
         exchanges|queues|messages|data|builders|tools|adapters|engines|
         formatters|parsers|middleware)/
       }x
-      EXCEPTION_PRIORITY = { warn: 0, error: 5, fatal: 9 }.freeze
+      LOGGING_PATH = __dir__
 
       def trace(raw_message = nil, size: @trace_size, log_caller: true)
         return unless @trace_enabled
@@ -23,83 +26,148 @@ module Legion
         elsif log_caller
           message.concat Rainbow(caller_locations[0..size]).cyan.underline
         end
-        log.unknown(message)
+        unknown(message)
       end
 
-      def debug(message = nil)
+      def debug(message = nil, task_id: nil, conv_id: nil, request_id: nil, exchange_id: nil, chain_id: nil, **_ctx)
         return unless log.level < 1
 
         message = yield if message.nil? && block_given?
+        if async_producer?
+          return defer_log_call(receiver: self, method_name: :debug, arguments: [message],
+                                keywords: { task_id: task_id, conv_id: conv_id, request_id: request_id,
+                                            exchange_id: exchange_id, chain_id: chain_id })
+        end
+
         raw = maybe_redact(message)
         formatted = format_message_for_level(:debug, raw)
-        write_async_or_sync(:debug, formatted, raw)
+        with_context_ids(task_id: task_id, conv_id: conv_id, request_id: request_id,
+                         exchange_id: exchange_id, chain_id: chain_id) do
+          write_async_or_sync(:debug, formatted, raw, writer_context: build_writer_context(:debug, raw))
+        end
       end
 
-      def info(message = nil)
+      def info(message = nil, task_id: nil, conv_id: nil, request_id: nil, exchange_id: nil, chain_id: nil, **_ctx)
         return unless log.level < 2
 
         message = yield if message.nil? && block_given?
+        if async_producer?
+          return defer_log_call(receiver: self, method_name: :info, arguments: [message],
+                                keywords: { task_id: task_id, conv_id: conv_id, request_id: request_id,
+                                            exchange_id: exchange_id, chain_id: chain_id })
+        end
+
         raw = maybe_redact(message)
         formatted = format_message_for_level(:info, raw)
-        write_async_or_sync(:info, formatted, raw)
+        with_context_ids(task_id: task_id, conv_id: conv_id, request_id: request_id,
+                         exchange_id: exchange_id, chain_id: chain_id) do
+          write_async_or_sync(:info, formatted, raw, writer_context: build_writer_context(:info, raw))
+        end
       end
 
-      def warn(message = nil)
+      def warn(message = nil, task_id: nil, conv_id: nil, request_id: nil, exchange_id: nil, chain_id: nil, **_ctx)
         return unless log.level < 3
 
         message = yield if message.nil? && block_given?
+        if async_producer?
+          return defer_log_call(receiver: self, method_name: :warn, arguments: [message],
+                                keywords: { task_id: task_id, conv_id: conv_id, request_id: request_id,
+                                            exchange_id: exchange_id, chain_id: chain_id })
+        end
+
         raw = maybe_redact(message)
         formatted = format_message_for_level(:warn, raw)
-        write_async_or_sync(:warn, formatted, raw, writer_context: build_writer_context(:warn, raw))
+        with_context_ids(task_id: task_id, conv_id: conv_id, request_id: request_id,
+                         exchange_id: exchange_id, chain_id: chain_id) do
+          write_async_or_sync(:warn, formatted, raw, writer_context: build_writer_context(:warn, raw))
+        end
       end
 
-      def error(message = nil)
+      def error(message = nil, task_id: nil, conv_id: nil, request_id: nil, exchange_id: nil, chain_id: nil, **_ctx)
         return unless log.level < 4
 
         message = yield if message.nil? && block_given?
+        if async_producer?
+          return defer_log_call(receiver: self, method_name: :error, arguments: [message],
+                                keywords: { task_id: task_id, conv_id: conv_id, request_id: request_id,
+                                            exchange_id: exchange_id, chain_id: chain_id })
+        end
+
         raw = maybe_redact(message)
         formatted = format_message_for_level(:error, raw)
-        write_async_or_sync(:error, formatted, raw, writer_context: build_writer_context(:error, raw))
+        with_context_ids(task_id: task_id, conv_id: conv_id, request_id: request_id,
+                         exchange_id: exchange_id, chain_id: chain_id) do
+          write_async_or_sync(:error, formatted, raw, writer_context: build_writer_context(:error, raw))
+        end
       end
 
-      def fatal(message = nil)
+      def fatal(message = nil, task_id: nil, conv_id: nil, request_id: nil, exchange_id: nil, chain_id: nil, **_ctx)
         return unless log.level < 5
 
         message = yield if message.nil? && block_given?
+        if async_producer?
+          return defer_log_call(receiver: self, method_name: :fatal, arguments: [message],
+                                keywords: { task_id: task_id, conv_id: conv_id, request_id: request_id,
+                                            exchange_id: exchange_id, chain_id: chain_id })
+        end
+
         raw = maybe_redact(message)
         formatted = format_message_for_level(:fatal, raw)
-        write_async_or_sync(:fatal, formatted, raw, writer_context: build_writer_context(:fatal, raw))
+        with_context_ids(task_id: task_id, conv_id: conv_id, request_id: request_id,
+                         exchange_id: exchange_id, chain_id: chain_id) do
+          write_async_or_sync(:fatal, formatted, raw, writer_context: build_writer_context(:fatal, raw))
+        end
       end
 
-      def unknown(message = nil)
+      def unknown(message = nil, task_id: nil, conv_id: nil, request_id: nil, exchange_id: nil, chain_id: nil, **_ctx)
         message = yield if message.nil? && block_given?
+        if async_producer?
+          return defer_log_call(receiver: self, method_name: :unknown, arguments: [message],
+                                keywords: { task_id: task_id, conv_id: conv_id, request_id: request_id,
+                                            exchange_id: exchange_id, chain_id: chain_id })
+        end
+
         raw = maybe_redact(message)
         formatted = format_message_for_level(:unknown, raw)
-        write_async_or_sync(:unknown, formatted, raw)
+        with_context_ids(task_id: task_id, conv_id: conv_id, request_id: request_id,
+                         exchange_id: exchange_id, chain_id: chain_id) do
+          write_async_or_sync(:unknown, formatted, raw, writer_context: build_writer_context(:unknown, raw))
+        end
       end
 
-      def emit_tagged(level, message = nil, segments: nil, method_ctx: nil)
+      def emit_tagged(level, message = nil, segments: nil, method_ctx: nil,
+                      task_id: nil, conv_id: nil, request_id: nil, exchange_id: nil, chain_id: nil, **_ctx)
         level = level.to_sym
         message = yield if message.nil? && block_given?
         return if message.nil?
+        if async_producer?
+          return defer_log_call(receiver: self, method_name: :emit_tagged, arguments: [level, message],
+                                keywords: { segments: segments, method_ctx: method_ctx, task_id: task_id, conv_id: conv_id,
+                                            request_id: request_id, exchange_id: exchange_id, chain_id: chain_id })
+        end
 
         raw = maybe_redact(message)
         formatted = format_message_for_level(level, raw)
 
         with_tagged_context(segments, method_ctx) do
-          ctx = %i[warn error fatal].include?(level) ? build_writer_context(level, raw) : nil
-          writer = @async_writer
-          caller_trace = capture_runner_trace_for_async
-          if writer&.alive?
-            writer.push(AsyncWriter::LogEntry.new(
-                          level: level, message: formatted, writer_context: ctx,
-                          segments: Thread.current[:legion_log_segments],
-                          method_ctx: Thread.current[:legion_log_method],
-                          caller_trace: caller_trace
-                        ))
-          else
-            with_caller_trace(caller_trace) { write_forced(level, formatted) }
-            fire_log_writer(level, raw) if ctx
+          with_context_ids(task_id: task_id, conv_id: conv_id, request_id: request_id,
+                           exchange_id: exchange_id, chain_id: chain_id) do
+            ctx = build_writer_context(level, raw)
+            writer = @async_writer
+            caller_trace = capture_runner_trace_for_async
+            if @async || writer
+              push_async_entry(entry: AsyncWriter::LogEntry.new(force: true, level: level, message: formatted, writer_context: ctx,
+                                                                segments: Thread.current[:legion_log_segments],
+                                                                method_ctx: Thread.current[:legion_log_method],
+                                                                caller_trace: caller_trace,
+                                                                conv_id: Thread.current[:legion_log_conv_id],
+                                                                request_id: Thread.current[:legion_log_request_id],
+                                                                exchange_id: Thread.current[:legion_log_exchange_id],
+                                                                chain_id: Thread.current[:legion_log_chain_id]))
+            else
+              with_caller_trace(caller_trace) { write_forced(level, formatted) }
+              fire_log_writer(level, raw, event: ctx[:event]) if ctx
+            end
           end
         end
       end
@@ -113,6 +181,14 @@ module Legion
                         gem_name: nil, lex_version: nil, gem_path: nil,
                         source_code_uri: nil, handled: false, payload_summary: nil,
                         task_id: nil, backtrace_limit: nil, **extra)
+        if async_producer?
+          return defer_log_call(receiver: self, method_name: :log_exception, arguments: [exception],
+                                keywords: { level: level, lex: lex, component_type: component_type, gem_name: gem_name,
+                                            lex_version: lex_version, gem_path: gem_path, source_code_uri: source_code_uri,
+                                            handled: handled, payload_summary: payload_summary, task_id: task_id,
+                                            backtrace_limit: backtrace_limit, **extra })
+        end
+
         level = level.to_sym if level.respond_to?(:to_sym)
         # 1. Log human-readable line + backtrace via async writer
         msg = exception.respond_to?(:message) ? exception.message : exception.to_s
@@ -142,7 +218,7 @@ module Legion
         event = Legion::Logging::Redactor.redact(event) if defined?(Legion::Logging::Redactor)
 
         # 4. Publish rich event via exception_writer
-        publish_exception_event(event, level)
+        publish_exception(event: event, level: level)
       rescue StandardError => e
         if respond_to?(:log) && log.respond_to?(:warn)
           log.warn("Failed to publish structured exception event: #{e.class}: #{e.message}")
@@ -151,6 +227,45 @@ module Legion
         end
       end
 
+      def publish_exception(event:, level:)
+        lex_name = event[:lex] || 'core'
+        component = event[:component_type] || :unknown
+        options = {
+          routing_key: "legion.logging.exception.#{level}.#{lex_name}.#{component}",
+          headers:     build_exception_headers(event, component, level),
+          properties:  build_exception_properties(event, level)
+        }
+        callback = Legion::Logging.exception_writer
+        writer = @async_writer
+        return push_async_entry(entry: AsyncWriter::EventEntry.new(callback: callback, event: event, options: options)) if @async || writer
+
+        callback.call(event, **options)
+      end
+
+      def async_producer?
+        (@async == true || !@async_writer.nil?) && !@async_writer&.current_thread?
+      end
+
+      def defer_log_call(receiver:, method_name:, arguments:, keywords:)
+        return false unless async_producer?
+        raise ClosedQueueError, 'async logging writer is unavailable' unless @async_writer&.alive?
+
+        context = Legion::Logging::AsyncWriter::CALL_THREAD_KEYS.to_h do |key|
+          [key, Legion::Logging::AsyncWriter.snapshot_value(value: Thread.current[key])]
+        end
+        location = caller_locations(1, 16).find do |frame|
+          path = frame.absolute_path || frame.path
+          !path.start_with?(LOGGING_PATH)
+        end
+        context[:legion_log_origin] = { location: location, timestamp: Time.now.utc, thread: Thread.current.object_id }
+        push_async_entry(entry: Legion::Logging::AsyncWriter::CallEntry.new(
+          receiver: receiver, method_name: method_name,
+          arguments: arguments.map { |value| Legion::Logging::AsyncWriter.snapshot_value(value: value) },
+          keywords: keywords.transform_values { |value| Legion::Logging::AsyncWriter.snapshot_value(value: value) },
+          context: context
+        ))
+      end
+
       def thread(kvl: false, **_opts)
         if kvl
           "thread=#{Thread.current.object_id}"
@@ -164,8 +279,9 @@ module Legion
       def resolve_backtrace_limit(explicit_limit)
         return explicit_limit unless explicit_limit.nil?
         return nil unless defined?(Legion::Settings)
+        return nil unless Legion::Settings.respond_to?(:loaded?) ? Legion::Settings.loaded? : true
 
-        Legion::Settings[:logging][:backtrace_limit]
+        Legion::Settings.dig(:logging, :backtrace_limit)
       end
 
       def build_exception_log_message(exception, msg, backtrace_limit)
@@ -237,29 +353,61 @@ module Legion
         level.to_s.upcase
       end
 
+      def with_context_ids(task_id: nil, conv_id: nil, request_id: nil, exchange_id: nil, chain_id: nil)
+        prev_conv     = Thread.current[:legion_log_conv_id]
+        prev_req      = Thread.current[:legion_log_request_id]
+        prev_exchange = Thread.current[:legion_log_exchange_id]
+        prev_chain    = Thread.current[:legion_log_chain_id]
+
+        context_id = conv_id || task_id || Thread.current[:legion_log_conv_id]
+        req_id = request_id || Thread.current[:legion_log_request_id]
+        exch_id = exchange_id || Thread.current[:legion_log_exchange_id]
+        ch_id = chain_id || Thread.current[:legion_log_chain_id]
+
+        Thread.current[:legion_log_conv_id]     = context_id if context_id.is_a?(String) && !context_id.empty?
+        Thread.current[:legion_log_request_id]  = req_id if req_id.is_a?(String) && !req_id.empty?
+        Thread.current[:legion_log_exchange_id] = exch_id if exch_id.is_a?(String) && !exch_id.empty?
+        Thread.current[:legion_log_chain_id]    = ch_id if ch_id.is_a?(String) && !ch_id.empty?
+        yield
+      ensure
+        Thread.current[:legion_log_conv_id]     = prev_conv
+        Thread.current[:legion_log_request_id]  = prev_req
+        Thread.current[:legion_log_exchange_id] = prev_exchange
+        Thread.current[:legion_log_chain_id]    = prev_chain
+      end
+
       def write_async_or_sync(level, formatted_message, raw_message, writer_context: nil)
         writer = @async_writer
         caller_trace = capture_runner_trace_for_async
-        if writer&.alive?
-          queued = writer.push(AsyncWriter::LogEntry.new(
-                                 level:          level,
-                                 message:        formatted_message,
-                                 writer_context: writer_context,
-                                 segments:       Thread.current[:legion_log_segments],
-                                 method_ctx:     Thread.current[:legion_log_method],
-                                 caller_trace:   caller_trace
-                               ))
-          return if queued
+        if @async || writer
+          return push_async_entry(entry: AsyncWriter::LogEntry.new(force: false, level:          level,
+                                                                   message:        formatted_message,
+                                                                   writer_context: writer_context,
+                                                                   segments:       Thread.current[:legion_log_segments],
+                                                                   method_ctx:     Thread.current[:legion_log_method],
+                                                                   caller_trace:   caller_trace,
+                                                                   conv_id:        Thread.current[:legion_log_conv_id],
+                                                                   request_id:     Thread.current[:legion_log_request_id],
+                                                                   exchange_id:    Thread.current[:legion_log_exchange_id],
+                                                                   chain_id:       Thread.current[:legion_log_chain_id]))
         end
 
         with_caller_trace(caller_trace) do
           log.public_send(level, formatted_message)
-          fire_log_writer(level, raw_message) if writer_context
+          fire_log_writer(level, raw_message, event: writer_context[:event]) if writer_context
         end
       end
 
+      def push_async_entry(entry:) # rubocop:disable Naming/PredicateMethod
+        writer = @async_writer
+        raise ClosedQueueError, 'async logging writer is unavailable' unless writer&.alive? && writer.push(entry)
+
+        true
+      end
+
       def capture_runner_trace_for_async
-        build_runner_trace(caller_locations(4, 1)&.first)
+        location = Thread.current[:legion_log_origin]&.[](:location) || caller_locations(5, 1)&.first
+        build_runner_trace(location)
       end
 
       def with_caller_trace(caller_trace)
@@ -270,17 +418,6 @@ module Legion
         Thread.current[:legion_log_caller] = prev_caller_trace
       end
 
-      def redaction_enabled?
-        return false unless defined?(Legion::Settings)
-
-        loader = Legion::Settings.instance_variable_get(:@loader)
-        return false unless loader
-
-        loader.dig(:logging, :redaction, :enabled) == true
-      rescue StandardError
-        false
-      end
-
       def build_log_headers(event, component, level)
         headers = {
           'legion_protocol_version' => '2.0',
@@ -301,102 +438,40 @@ module Legion
           timestamp:     Time.now.to_i,
           app_id:        'legionio',
           type:          'log_event',
-          priority:      EXCEPTION_PRIORITY[level] || 0,
+          priority:      HeaderBuilder::EXCEPTION_PRIORITY[level] || 0,
           delivery_mode: 2
         }
       end
 
-      def append_identity_headers(headers)
-        return unless defined?(Legion::Identity::Process)
-        return if Legion::Identity::Process.respond_to?(:resolved?) && !Legion::Identity::Process.resolved?
-
-        id = identity_hash
-        append_optional_header(headers, 'x-legion-identity-canonical-name', id[:canonical_name])
-        append_optional_header(headers, 'x-legion-identity-trust', id[:trust])
-        append_optional_header(headers, 'x-legion-identity-id', id[:id])
-        append_optional_header(headers, 'x-legion-identity-kind', id[:kind])
-        append_optional_header(headers, 'x-legion-identity-mode', id[:mode])
-        append_optional_header(headers, 'x-legion-identity-source', id[:source])
-        headers['x-legion-identity-db-principal-id'] = id[:db_principal_id] if id[:db_principal_id]
-        headers['x-legion-identity-db-identity-id'] = id[:db_identity_id] if id[:db_identity_id]
-      rescue StandardError
-        nil
-      end
-
-      def publish_exception_event(event, level)
-        lex_name = event[:lex] || 'core'
-        comp     = event[:component_type] || :unknown
-        routing_key = "legion.logging.exception.#{level}.#{lex_name}.#{comp}"
-        headers     = build_exception_headers(event, comp, level)
-        properties  = build_exception_properties(event, level)
-        Legion::Logging.exception_writer.call(event, routing_key: routing_key, headers: headers, properties: properties)
-      end
-
-      def build_exception_headers(event, comp, level)
-        headers = {
-          'legion_protocol_version' => '2.0',
-          'x-error-fingerprint'     => event[:error_fingerprint],
-          'x-exception-class'       => event[:exception_class],
-          'x-handled'               => event[:handled].to_s,
-          'x-gem-name'              => event[:gem_name].to_s,
-          'x-lex-version'           => event[:lex_version].to_s,
-          'x-component-type'        => comp.to_s,
-          'x-level'                 => level.to_s
-        }
-        append_legion_version_header(headers)
-        append_optional_header(headers, 'x-task-id', event[:task_id])
-        append_optional_header(headers, 'x-conversation-id', event[:conversation_id])
-        append_optional_header(headers, 'x-user', event[:user])
-        append_identity_headers(headers)
-        headers
+      def forward_level?(level)
+        forwardable_log_levels.include?(level.to_sym)
       end
 
-      def append_optional_header(headers, key, value)
-        return if value.nil?
-        return if value.respond_to?(:empty?) && value.empty?
+      # Levels whose logs build a structured event for the transport bus / Hooks.
+      # Runtime override: logging.transport.log_levels (Array of level names).
+      # Falls back to Settings.default[:forward_log_levels] (warn/error/fatal).
+      def forwardable_log_levels
+        default = Legion::Logging::Settings::DEFAULT_FORWARD_LOG_LEVELS
+        return default unless defined?(Legion::Settings)
+        return default unless Legion::Settings.respond_to?(:loaded?) ? Legion::Settings.loaded? : true
 
-        headers[key] = value.to_s
-      end
+        configured = Legion::Settings.dig(:logging, :transport, :log_levels)
+        return default unless configured.is_a?(Array) && !configured.empty?
 
-      def append_legion_version_header(headers)
-        append_optional_header(headers, 'x-legion-version', Legion::VERSION) if defined?(Legion::VERSION)
-      end
-
-      def identity_hash
-        process = Legion::Identity::Process
-        return process.identity_hash if process.respond_to?(:identity_hash)
-
-        {
-          canonical_name: identity_value(process, :canonical_name),
-          id:             identity_value(process, :id),
-          kind:           identity_value(process, :kind),
-          mode:           identity_value(process, :mode),
-          source:         identity_value(process, :source),
-          trust:          identity_value(process, :trust)
-        }
-      end
-
-      def identity_value(process, method_name)
-        process.public_send(method_name) if process.respond_to?(method_name)
-      end
-
-      def build_exception_properties(event, level)
-        {
-          content_type:   'application/json',
-          message_id:     SecureRandom.uuid,
-          correlation_id: event[:error_fingerprint],
-          timestamp:      Time.now.to_i,
-          app_id:         'legionio',
-          type:           'exception_event',
-          priority:       EXCEPTION_PRIORITY[level] || 5,
-          delivery_mode:  2
-        }
+        configured.map { |lvl| lvl.to_s.to_sym }
+      rescue StandardError => e
+        Kernel.warn("Legion::Logging forwarding configuration failed: #{e.message}")
+        default
       end
 
       def build_writer_context(level, message)
+        # Cheap ivar/flag checks first: when nothing consumes forwarded events
+        # (the common case) we return before touching Settings, keeping the
+        # hot debug/info path allocation- and lookup-free.
         has_writer = !Legion::Logging.instance_variable_get(:@log_writer).nil?
         has_hooks = defined?(Legion::Logging::Hooks) && Legion::Logging::Hooks.enabled?
         return nil unless has_writer || has_hooks
+        return nil unless forward_level?(level)
 
         lex_val  = instance_variable_defined?(:@lex) ? @lex : nil
         lex_segs = Thread.current[:legion_log_segments] || (instance_variable_defined?(:@lex_segments) ? @lex_segments : nil)
@@ -411,17 +486,7 @@ module Legion
         { level: level, event: event }
       end
 
-      def fire_log_writer(level, message)
-        lex_val  = instance_variable_defined?(:@lex) ? @lex : nil
-        lex_segs = Thread.current[:legion_log_segments] || (instance_variable_defined?(:@lex_segments) ? @lex_segments : nil)
-
-        event = Legion::Logging::EventBuilder.build(
-          level:         level,
-          message:       message,
-          lex:           lex_val,
-          lex_segments:  lex_segs,
-          caller_offset: 4
-        )
+      def fire_log_writer(level, message, event:)
         lex_name = event[:lex] || 'core'
         component = event.dig(:caller, :file).to_s[COMPONENT_REGEX, 1] || 'unknown'
         routing_key = "legion.logging.log.#{level}.#{lex_name}.#{component}"

data/lib/legion/logging/multi_io.rb

@@ -10,6 +10,8 @@ module Legion
       def write(message)
         @targets.each do |t|
           t.write(message)
+        rescue StandardError => e
+          warn("Legion::Logging::MultiIO#write failed for #{t.class}: #{e.message}")
         end
       end
 

data/lib/legion/logging/output_logger.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require 'logger'
+
+module Legion
+  module Logging
+    # Keeps the standard Logger interface used by Sinatra/APM on the async queue.
+    class OutputLogger < ::Logger
+      attr_accessor :async_writer
+
+      def add(severity, message = nil, progname = nil)
+        writer = @async_writer
+        return super unless writer && !writer.current_thread?
+
+        severity ||= UNKNOWN
+        return true if @logdev.nil? || severity < level
+
+        progname ||= @progname
+        if message.nil?
+          if block_given?
+            message = yield
+          else
+            message = progname
+            progname = @progname
+          end
+        end
+        enqueue_output(severity: severity, message: message, progname: progname)
+      end
+      alias log add
+
+      def <<(message)
+        writer = @async_writer
+        return super unless writer && !writer.current_thread?
+
+        enqueue_output(severity: nil, message: message, progname: nil)
+      end
+
+      private
+
+      def enqueue_output(severity:, message:, progname:) # rubocop:disable Naming/PredicateMethod
+        entry = Legion::Logging::AsyncWriter::OutputEntry.new(
+          severity:     severity,
+          message:      Legion::Logging::AsyncWriter.snapshot_value(value: message),
+          progname:     Legion::Logging::AsyncWriter.snapshot_value(value: progname),
+          segments:     Legion::Logging::AsyncWriter.snapshot_value(value: Thread.current[:legion_log_segments]),
+          method_ctx:   Legion::Logging::AsyncWriter.snapshot_value(value: Thread.current[:legion_log_method]),
+          caller_trace: Legion::Logging::AsyncWriter.snapshot_value(value: Thread.current[:legion_log_caller]),
+          conv_id:      Legion::Logging::AsyncWriter.snapshot_value(value: Thread.current[:legion_log_conv_id]),
+          request_id:   Legion::Logging::AsyncWriter.snapshot_value(value: Thread.current[:legion_log_request_id]),
+          exchange_id:  Legion::Logging::AsyncWriter.snapshot_value(value: Thread.current[:legion_log_exchange_id]),
+          chain_id:     Legion::Logging::AsyncWriter.snapshot_value(value: Thread.current[:legion_log_chain_id]),
+          origin:       { timestamp: Time.now.utc, thread: Thread.current.object_id }
+        )
+        raise ClosedQueueError, 'async logging writer is unavailable' unless @async_writer.alive? && @async_writer.push(entry)
+
+        true
+      end
+    end
+  end
+end

data/lib/legion/logging/redactor.rb

@@ -74,6 +74,9 @@ module Legion
         end
 
         def all_patterns
+          return PATTERNS unless defined?(Legion::Settings)
+          return PATTERNS unless Legion::Settings.respond_to?(:loaded?) ? Legion::Settings.loaded? : true
+
           @all_patterns ||= build_patterns
         end
 
@@ -85,8 +88,6 @@ module Legion
         end
 
         def custom_patterns
-          return {} unless defined?(Legion::Settings)
-
           raw = Legion::Settings.dig(:logging, :redactor, :custom_patterns)
           return {} unless raw.is_a?(Hash)
 

data/lib/legion/logging/settings.rb

@@ -3,15 +3,31 @@
 module Legion
   module Logging
     module Settings
+      # Log levels forwarded to the transport bus (and in-process Hooks) by
+      # default. Preserves historic behavior: only warn/error/fatal logs build a
+      # structured event. Override at runtime via logging.transport.log_levels
+      # (e.g. add :debug/:info) — see Methods#forwardable_log_levels.
+      DEFAULT_FORWARD_LOG_LEVELS = %i[warn error fatal].freeze
+
       def self.default
         {
-          level:           :info,
-          trace:           true,
-          trace_size:      4,
-          extended:        true,
-          backtrace_limit: nil
+          level:              :info,
+          trace:              true,
+          trace_size:         4,
+          extended:           true,
+          backtrace_limit:    nil,
+          forward_log_levels: DEFAULT_FORWARD_LOG_LEVELS
         }
       end
+
+      def self.async_buffer_size
+        return 10_000 unless defined?(Legion::Settings) && Legion::Settings.respond_to?(:[])
+        return 10_000 unless Legion::Settings.respond_to?(:loaded?) ? Legion::Settings.loaded? : true
+
+        logging = Legion::Settings[:logging]
+        async = logging[:async] if logging.is_a?(Hash)
+        async.is_a?(Hash) ? (async[:buffer_size] || 10_000) : 10_000
+      end
     end
   end
 end

data/lib/legion/logging/shipper/file_transport.rb

@@ -26,7 +26,7 @@ module Legion
             end
             true
           rescue StandardError => e
-            Legion::Logging.error("FileTransport ship failed: #{e.message}") if defined?(Legion::Logging)
+            Kernel.warn("FileTransport ship failed: #{e.message}")
             false
           end
 
@@ -40,6 +40,7 @@ module Legion
 
           def settings_path
             return nil unless defined?(Legion::Settings)
+            return nil unless Legion::Settings.respond_to?(:loaded?) ? Legion::Settings.loaded? : true
 
             Legion::Settings.dig(:logging, :shipper, :file, :path)
           end