legion-logging 1.5.4 → 1.5.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3a7e958bdf135cd4798a6619992fd2661a9864b13dab2133c378d67ccea54380
-  data.tar.gz: 280391287ca3a8e15f91979e63bdbb3f4f7bab3c0e71bcc1f47b9a4eac378cb0
+  metadata.gz: ff7f461a7f614eb2480b2ef960992d463c7e26ee8cae0283d9f381e859e28c8d
+  data.tar.gz: a5bc8f5e7fd81d72ef8cc4ae98225e677645581340611103ac99807bb2f6c691
 SHA512:
-  metadata.gz: 55b8db2c9e50ad4d9d91f10379821c33c0cacdeed46a1da16a23d49835108f65ab9d59305bd3c421219510932d58f684c2816c7b39e39d51dc36ad65396a8afe
-  data.tar.gz: c7914b118692f0e2738ab5a68af4290e117b275b320a43a548ae5e85366f6f8cfec5f16f3c611f2b47a9f7e90a5446063f77c97ef3bb98a5e169a6dee177e9ad
+  metadata.gz: 006d30ed434deec409edd42ca5b5ac9245a4657dc8fc6280fc8b982c704d9ef1b1aee299bf6f905698a382f84cbc5ca3205adfd4691f2010d6aec0dea818a986
+  data.tar.gz: f6288442156789fd8bbb9858910a3deb01fffea277341c2c0e5b8288ee3cab7150b07b4c348faad78b3645f808823f536a856140fc1c5ce4935b4b805d13caea

data/CHANGELOG.md

@@ -1,5 +1,23 @@
 # Legion::Logging Changelog
 
+## [1.5.6] - 2026-06-01
+
+### Added
+- `task_id:`, `conv_id:`, `request_id:` optional kwargs on all log level methods (`.debug`, `.info`, `.warn`, `.error`, `.fatal`, `.unknown`) in both `Methods` and `TaggedLogger`
+- Text formatter appends context ID (`conv_id` or `task_id` fallback) as `{conv_12345}` after the method segment in the prefix
+- Text formatter inserts `request_id=<value>` between severity and message when present
+- JSON formatter includes `conversation_id` and `request_id` fields when present
+- `AsyncWriter::LogEntry` carries `conv_id` and `request_id` for correct propagation to the writer thread
+- Thread-local `legion_log_conv_id` and `legion_log_request_id` for block-scoped context without per-call kwargs
+
+## [1.5.5] - 2026-05-27
+
+### Fixed
+- `emit_tagged` (used by all Legion::Logging::Helper consumers) now routes through the async writer instead of doing synchronous IO#write — eliminates IO mutex contention across all consumer threads
+- `fatal` level now routes through async writer consistently with all other levels
+- `log_exception` now writes through async writer instead of direct `log.public_send`
+- `Legion::Logging::Logger` defaults to `async: true`, ensuring all per-extension logger instances use non-blocking writes
+
 ## [1.5.4] - 2026-05-22
 
 ### Added

data/lib/legion/logging/async_writer.rb

@@ -5,8 +5,13 @@ require_relative 'methods'
 module Legion
   module Logging
     class AsyncWriter
-      LogEntry = ::Data.define(:level, :message, :writer_context, :segments, :method_ctx, :caller_trace)
+      LogEntry = ::Data.define(:level, :message, :writer_context, :segments, :method_ctx, :caller_trace,
+                               :conv_id, :request_id, :exchange_id, :chain_id)
       SHUTDOWN = :shutdown
+      THREAD_KEYS = %i[
+        legion_log_segments legion_log_method legion_log_caller
+        legion_log_conv_id legion_log_request_id legion_log_exchange_id legion_log_chain_id
+      ].freeze
 
       attr_reader :logger
 
@@ -74,20 +79,26 @@ module Legion
       end
 
       def write_entry(entry)
-        prev_segments   = Thread.current[:legion_log_segments]
-        prev_method_ctx = Thread.current[:legion_log_method]
-        prev_caller     = Thread.current[:legion_log_caller]
-        Thread.current[:legion_log_segments] = entry.segments
-        Thread.current[:legion_log_method]   = entry.method_ctx
-        Thread.current[:legion_log_caller]   = entry.caller_trace
-        @logger.send(entry.level, entry.message)
-        fire_writer(entry) if entry.writer_context
+        with_entry_context(entry) do
+          @logger.send(entry.level, entry.message)
+          fire_writer(entry) if entry.writer_context
+        end
       rescue StandardError => e
         warn("legion-log-writer error: #{e.message} (#{e.backtrace&.first})")
+      end
+
+      def with_entry_context(entry)
+        prev = THREAD_KEYS.map { |k| [k, Thread.current[k]] }
+        Thread.current[:legion_log_segments]    = entry.segments
+        Thread.current[:legion_log_method]      = entry.method_ctx
+        Thread.current[:legion_log_caller]      = entry.caller_trace
+        Thread.current[:legion_log_conv_id]     = entry.conv_id
+        Thread.current[:legion_log_request_id]  = entry.request_id
+        Thread.current[:legion_log_exchange_id] = entry.exchange_id
+        Thread.current[:legion_log_chain_id]    = entry.chain_id
+        yield
       ensure
-        Thread.current[:legion_log_segments] = prev_segments
-        Thread.current[:legion_log_method]   = prev_method_ctx
-        Thread.current[:legion_log_caller]   = prev_caller
+        prev&.each { |k, v| Thread.current[k] = v }
       end
 
       def drain

data/lib/legion/logging/builder.rb

@@ -31,6 +31,14 @@ module Legion
           entry[:segments] = segments if segments
           method_ctx = Thread.current[:legion_log_method]
           entry[:method] = method_ctx if method_ctx
+          conv_id = Thread.current[:legion_log_conv_id]
+          entry[:conversation_id] = conv_id if conv_id.is_a?(String) && !conv_id.empty?
+          request_id = Thread.current[:legion_log_request_id]
+          entry[:request_id] = request_id if request_id.is_a?(String) && !request_id.empty?
+          exchange_id = Thread.current[:legion_log_exchange_id]
+          entry[:exchange_id] = exchange_id if exchange_id.is_a?(String) && !exchange_id.empty?
+          chain_id = Thread.current[:legion_log_chain_id]
+          entry[:chain_id] = chain_id if chain_id.is_a?(String) && !chain_id.empty?
           "#{::JSON.generate(entry)}\n"
         rescue StandardError => e
           warn("Legion::Logging::Builder#json_format formatter failed: #{e.message}")
@@ -49,7 +57,12 @@ module Legion
           if runner_trace.is_a?(Hash) && (options[:extended] || severity == 'debug')
             string.concat("[#{runner_trace[:type]}:#{runner_trace[:file]}:#{runner_trace[:function]}:#{runner_trace[:line_number]}]")
           end
-          string.concat(" #{severity} #{msg}\n")
+          ctx_pairs = build_context_kv_pairs
+          if ctx_pairs.empty?
+            string.concat(" #{severity} #{msg}\n")
+          else
+            string.concat(" #{severity} #{msg} #{ctx_pairs}\n")
+          end
           string
         end
       end
@@ -66,9 +79,23 @@ module Legion
 
         method_ctx = Thread.current[:legion_log_method]
         tag = "#{tag}{#{method_ctx}}" if tag && method_ctx
+
+        context_id = Thread.current[:legion_log_conv_id]
+        tag = "#{tag}{#{context_id}}" if tag && context_id.is_a?(String) && !context_id.empty?
         tag
       end
 
+      def build_context_kv_pairs
+        pairs = []
+        request_id = Thread.current[:legion_log_request_id]
+        pairs << "request_id=#{request_id}" if request_id.is_a?(String) && !request_id.empty?
+        exchange_id = Thread.current[:legion_log_exchange_id]
+        pairs << "exchange_id=#{exchange_id}" if exchange_id.is_a?(String) && !exchange_id.empty?
+        chain_id = Thread.current[:legion_log_chain_id]
+        pairs << "chain_id=#{chain_id}" if chain_id.is_a?(String) && !chain_id.empty?
+        pairs.join(' ')
+      end
+
       def build_runner_trace(loc = caller_locations(6, 1)&.first)
         return unless loc
 

data/lib/legion/logging/header_builder.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+
+module Legion
+  module Logging
+    module HeaderBuilder
+      EXCEPTION_PRIORITY = { warn: 0, error: 5, fatal: 9 }.freeze
+
+      private
+
+      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-chain-id', event[:chain_id])
+        append_optional_header(headers, 'x-user', event[:user])
+        append_identity_headers(headers)
+        headers
+      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
+        }
+      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 append_optional_header(headers, key, value)
+        return if value.nil?
+        return if value.respond_to?(:empty?) && value.empty?
+
+        headers[key] = value.to_s
+      end
+
+      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 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
+    end
+  end
+end

data/lib/legion/logging/helper.rb

@@ -3,10 +3,13 @@
 require 'securerandom'
 require_relative 'tagged_logger'
 require_relative 'method_tracer'
+require_relative 'header_builder'
 
 module Legion
   module Logging
     module Helper
+      include Legion::Logging::HeaderBuilder
+
       SEGMENT_CACHE = {} # rubocop:disable Style/MutableConstant
       SEGMENT_CACHE_MUTEX = Mutex.new
       private_constant :SEGMENT_CACHE_MUTEX
@@ -32,7 +35,6 @@ module Legion
         'middleware' => :middleware
       }.freeze
 
-      EXCEPTION_PRIORITY = { warn: 0, error: 5, fatal: 9 }.freeze
       EXCEPTION_COLORS = {
         fatal:   :darkred,
         error:   :red,
@@ -359,27 +361,64 @@ module Legion
         return unless defined?(Legion::Settings)
         return unless Legion::Settings.respond_to?(:loaded?) ? Legion::Settings.loaded? : true
 
-        key = derive_component_settings_key
-        return unless key
+        keys = derive_component_settings_keys
+        return unless keys&.any?
+
+        if keys.length > 1
+          result = dig_settings(Legion::Settings[:extensions], keys)
+          return result if result.is_a?(Hash)
+        end
 
-        top_level = Legion::Settings[key]
+        single_key = keys.length == 1 ? keys.first : keys.join('_').to_sym
+        top_level = Legion::Settings[single_key]
         return top_level if top_level.is_a?(Hash)
 
-        extension_settings = Legion::Settings.dig(:extensions, key)
+        extension_settings = if keys.length > 1
+                               dig_settings(Legion::Settings[:extensions], keys)
+                             else
+                               Legion::Settings.dig(:extensions, single_key)
+                             end
         extension_settings if extension_settings.is_a?(Hash)
       rescue StandardError
         nil
       end
 
-      def derive_component_settings_key
+      def derive_component_settings_keys
+        key = respond_to?(:ancestors) ? ancestors.first : self.class
+        parts = key.to_s.split('::')
+        parts.shift if parts.first == 'Legion'
+
+        if parts.first == 'Extensions'
+          parts.shift
+          ext_parts = parts.take_while { |p| !COMPONENT_MAP.key?(p.downcase) }
+          return ext_parts.map { |p| camelize_to_snake_key(p).to_sym } if ext_parts.any?
+        elsif parts.first && !parts.first.start_with?('#')
+          return [camelize_to_snake_key(parts.first).to_sym]
+        end
+
         base = log_name
         return unless base
 
-        base.to_s.tr('-', '_').to_sym
+        base.to_s.split('-').map { |s| s.tr('-', '_').to_sym }
       rescue StandardError
         nil
       end
 
+      def camelize_to_snake_key(str)
+        str.to_s
+           .gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+           .gsub(/([a-z\d])([A-Z])/, '\1_\2')
+           .downcase
+      end
+
+      def dig_settings(hash, keys)
+        keys.reduce(hash) do |current, key|
+          return nil unless current.is_a?(Hash)
+
+          current[key] || current[key.to_s]
+        end
+      end
+
       def global_log_level
         runtime_level = if defined?(Legion::Logging) &&
                            Legion::Logging.respond_to?(:current_settings)
@@ -468,15 +507,7 @@ module Legion
         Thread.current[:legion_log_segments] = segments
 
         message = format_exception_output(exception, event)
-        message = Legion::Logging::Redactor.redact_string(message) if defined?(Legion::Logging::Redactor) && redaction_enabled?
-        message = colorize_exception(message, level) if Legion::Logging.respond_to?(:color) && Legion::Logging.color
-
-        logger = Legion::Logging.respond_to?(:log) ? Legion::Logging.log : nil
-        if logger.respond_to?(level)
-          logger.public_send(level, message)
-        elsif Legion::Logging.respond_to?(level)
-          Legion::Logging.public_send(level, message)
-        end
+        Legion::Logging.public_send(level, message) if Legion::Logging.respond_to?(level)
       ensure
         Thread.current[:legion_log_segments] = prev_segs
       end
@@ -524,17 +555,6 @@ module Legion
         parts.join(' | ')
       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
-
       # -- Exception structured publish --
 
       def publish_exception(event, level)
@@ -556,85 +576,6 @@ module Legion
         defined?(Legion::Logging::EventBuilder) &&
           Legion::Logging.respond_to?(:exception_writer)
       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)
-        headers['x-task-id'] = event[:task_id].to_s if event[:task_id]
-        headers['x-conversation-id'] = event[:conversation_id].to_s if event[:conversation_id]
-        headers['x-chain-id'] = event[:chain_id].to_s if event[:chain_id]
-        headers['x-user'] = event[:user].to_s if event[:user]
-        append_identity_headers(headers)
-        headers
-      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 append_optional_header(headers, key, value)
-        return if value.nil?
-        return if value.respond_to?(:empty?) && value.empty?
-
-        headers[key] = value.to_s
-      end
-
-      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
-        }
-      end
     end
   end
 end

data/lib/legion/logging/hooks.rb

@@ -19,7 +19,7 @@ module Legion
         def fire(level, message, event)
           return unless @enabled
 
-          hooks_for(level).each do |hook|
+          hooks_for(level).dup.each do |hook|
             hook.call(message, event)
           rescue StandardError => e
             warn("Legion::Logging::Hooks#fire callback failed: #{e.message}")

data/lib/legion/logging/logger.rb

@@ -11,7 +11,7 @@ module Legion
       include Legion::Logging::Methods
       include Legion::Logging::Builder
 
-      def initialize(level: 'info', log_file: nil, log_stdout: nil, lex: nil, trace: false, extended: false, trace_size: 4, format: :text, async: false, **opts)
+      def initialize(level: 'info', log_file: nil, log_stdout: nil, lex: nil, trace: false, extended: false, trace_size: 4, format: :text, async: true, **opts)
         @lex = lex
         set_log(logfile: log_file, log_stdout: log_stdout)
         log_level(level)

data/lib/legion/logging/methods.rb

@@ -1,16 +1,18 @@
 # 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
 
       def trace(raw_message = nil, size: @trace_size, log_caller: true)
         return unless @trace_enabled
@@ -26,61 +28,78 @@ module Legion
         log.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?
         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)
+        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?
         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)
+        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?
         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?
         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?
-        message = maybe_redact(message)
-        raw = message
-        message = Rainbow(message).darkred if @color
-        log.fatal(message)
-        fire_log_writer(:fatal, raw)
+        raw = maybe_redact(message)
+        formatted = format_message_for_level(: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?
         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)
+        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?
@@ -89,8 +108,27 @@ module Legion
         formatted = format_message_for_level(level, raw)
 
         with_tagged_context(segments, method_ctx) do
-          write_forced(level, formatted)
-          fire_log_writer(level, raw) if %i[warn error fatal].include?(level)
+          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 = %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,
+                            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) if ctx
+            end
+          end
         end
       end
 
@@ -104,11 +142,12 @@ module Legion
                         source_code_uri: nil, handled: false, payload_summary: nil,
                         task_id: nil, backtrace_limit: nil, **extra)
         level = level.to_sym if level.respond_to?(:to_sym)
-        # 1. Log human-readable line + backtrace to stdout/file (bypass writer callbacks)
+        # 1. Log human-readable line + backtrace via async writer
         msg = exception.respond_to?(:message) ? exception.message : exception.to_s
         msg = maybe_redact(msg)
         msg = build_exception_log_message(exception, msg, backtrace_limit)
-        log.public_send(level, msg) if respond_to?(:log) && log.respond_to?(level)
+        formatted = format_message_for_level(level, msg)
+        write_async_or_sync(level, formatted, msg)
 
         # 2. Build rich exception event
         event = Legion::Logging::EventBuilder.build_exception(
@@ -226,6 +265,29 @@ 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
@@ -236,7 +298,11 @@ module Legion
                                  writer_context: writer_context,
                                  segments:       Thread.current[:legion_log_segments],
                                  method_ctx:     Thread.current[:legion_log_method],
-                                 caller_trace:   caller_trace
+                                 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]
                                ))
           return if queued
         end
@@ -248,7 +314,7 @@ module Legion
       end
 
       def capture_runner_trace_for_async
-        build_runner_trace(caller_locations(4, 1)&.first)
+        build_runner_trace(caller_locations(5, 1)&.first)
       end
 
       def with_caller_trace(caller_trace)
@@ -259,17 +325,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',
@@ -290,28 +345,11 @@ 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
@@ -321,67 +359,6 @@ module Legion
         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
-      end
-
-      def append_optional_header(headers, key, value)
-        return if value.nil?
-        return if value.respond_to?(:empty?) && value.empty?
-
-        headers[key] = value.to_s
-      end
-
-      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
-        }
-      end
-
       def build_writer_context(level, message)
         has_writer = !Legion::Logging.instance_variable_get(:@log_writer).nil?
         has_hooks = defined?(Legion::Logging::Hooks) && Legion::Logging::Hooks.enabled?

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/shipper.rb

@@ -25,43 +25,49 @@ module Legion
         end
 
         def flush
-          return if @buffer.nil? || @buffer.empty?
+          @mutex ||= Mutex.new
+          batch = @mutex.synchronize do
+            return true if @buffer.nil? || @buffer.empty?
 
-          transport = TRANSPORTS[transport_type]
-          return unless transport
+            flushed = @buffer.dup
+            @buffer.clear
+            flushed
+          end
 
-          @flush_mutex ||= Mutex.new
-          @flush_mutex.synchronize do
-            batch = nil
-            @mutex.synchronize { batch = @buffer.dup }
-            return if batch.empty?
+          transport = TRANSPORTS[transport_type]
+          return true unless transport
 
-            delivered = deliver(transport, batch)
-            @mutex.synchronize { @buffer.shift(batch.size) if delivered }
-            delivered
-          end
+          delivered = deliver(transport, batch)
+          @mutex.synchronize { @buffer.prepend(*batch) } unless delivered
+          delivered
         end
 
         def start
-          return unless enabled?
-          return if @flush_thread&.alive?
-
-          @buffer ||= []
-          @mutex  ||= Mutex.new
-          @flush_mutex ||= Mutex.new
-          interval = flush_interval
-          @flush_thread = Thread.new do
-            loop do
-              sleep interval
-              flush
+          @start_mutex ||= Mutex.new
+          @start_mutex.synchronize do
+            return unless enabled?
+            return if @flush_thread&.alive?
+
+            @buffer ||= []
+            @mutex  ||= Mutex.new
+            @running = true
+            interval = flush_interval
+            @flush_thread = Thread.new do
+              while @running
+                sleep interval
+                flush
+              end
             end
+            @flush_thread.name = 'legion-log-shipper'
+            @flush_thread.abort_on_exception = false
           end
-          @flush_thread.abort_on_exception = false
         end
 
         def stop
-          @flush_thread&.kill
+          @running = false
+          thread = @flush_thread
           @flush_thread = nil
+          thread&.join(5)
           flush
         end
 
@@ -74,8 +80,8 @@ module Legion
         private
 
         def buffer_event(event)
-          @buffer  ||= []
-          @mutex   ||= Mutex.new
+          @buffer ||= []
+          @mutex  ||= Mutex.new
 
           full = false
           @mutex.synchronize do

data/lib/legion/logging/siem_exporter.rb

@@ -28,7 +28,8 @@ module Legion
           req['Content-Type'] = 'application/json'
           req.body = ::JSON.dump({ event: redact_phi(event.to_s), time: Time.now.to_f })
 
-          Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == 'https') do |http|
+          Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == 'https',
+                                                     open_timeout: 5, read_timeout: 10) do |http|
             http.request(req)
           end
         rescue StandardError => e

data/lib/legion/logging/tagged_logger.rb

@@ -32,44 +32,44 @@ module Legion
         @level_value
       end
 
-      def debug(message = nil)
+      def debug(message = nil, **ctx)
         return unless @level_value < 1
 
         message = yield if message.nil? && block_given?
-        with_segments { dispatch(:debug, message) }
+        with_segments { dispatch(:debug, message, **ctx) }
       end
 
-      def info(message = nil)
+      def info(message = nil, **ctx)
         return unless @level_value < 2
 
         message = yield if message.nil? && block_given?
-        with_segments { dispatch(:info, message) }
+        with_segments { dispatch(:info, message, **ctx) }
       end
 
-      def warn(message = nil)
+      def warn(message = nil, **ctx)
         return unless @level_value < 3
 
         message = yield if message.nil? && block_given?
-        with_segments { dispatch(:warn, message) }
+        with_segments { dispatch(:warn, message, **ctx) }
       end
 
-      def error(message = nil)
+      def error(message = nil, **ctx)
         return unless @level_value < 4
 
         message = yield if message.nil? && block_given?
-        with_segments { dispatch(:error, message) }
+        with_segments { dispatch(:error, message, **ctx) }
       end
 
-      def fatal(message = nil)
+      def fatal(message = nil, **ctx)
         return unless @level_value < 5
 
         message = yield if message.nil? && block_given?
-        with_segments { dispatch(:fatal, message) }
+        with_segments { dispatch(:fatal, message, **ctx) }
       end
 
-      def unknown(message = nil)
+      def unknown(message = nil, **ctx)
         message = yield if message.nil? && block_given?
-        with_segments { dispatch(:unknown, message) }
+        with_segments { dispatch(:unknown, message, **ctx) }
       end
 
       def trace(raw_message = nil, size: @trace_size, log_caller: true)
@@ -94,21 +94,23 @@ module Legion
 
       private
 
-      def dispatch(level, message)
+      def dispatch(level, message, **ctx)
         return unless defined?(Legion::Logging)
 
         if Legion::Logging.respond_to?(:emit_tagged)
-          Legion::Logging.emit_tagged(level, message, segments: @segments)
+          Legion::Logging.emit_tagged(level, message, segments: @segments, **ctx)
           return
         end
 
         if Legion::Logging.respond_to?(level)
-          Legion::Logging.public_send(level, message)
+          Legion::Logging.public_send(level, message, **ctx)
           return
         end
 
         fallback = fallback_level(level)
-        Legion::Logging.public_send(fallback, message) if fallback && Legion::Logging.respond_to?(fallback)
+        return unless fallback && Legion::Logging.respond_to?(fallback)
+
+        Legion::Logging.public_send(fallback, message, **ctx)
       end
 
       def fallback_level(level)

data/lib/legion/logging/version.rb

@@ -2,6 +2,6 @@
 
 module Legion
   module Logging
-    VERSION = '1.5.4'
+    VERSION = '1.5.6'
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: legion-logging
 version: !ruby/object:Gem::Version
-  version: 1.5.4
+  version: 1.5.6
 platform: ruby
 authors:
 - Esity
@@ -63,6 +63,7 @@ files:
 - lib/legion/logging/builder.rb
 - lib/legion/logging/category_registry.rb
 - lib/legion/logging/event_builder.rb
+- lib/legion/logging/header_builder.rb
 - lib/legion/logging/helper.rb
 - lib/legion/logging/hooks.rb
 - lib/legion/logging/logger.rb