legion-logging 1.5.3 → 1.5.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f751e228eb4c00edae10784b3edf4176afb2f84ec7a8df1525a9c8432145c50f
-  data.tar.gz: 728db26335f6bffdcef54523760d9b8051615f0bee280ac01a897a3373b3403f
+  metadata.gz: cd5e1bffbdc433aedb24653ea515080063cb456de0c5a0fd5a57cdbff91d371d
+  data.tar.gz: 0b015f1b0c5d12511f231bfa32325e2ebcc41ca902b92d8293bdcf6359d8a7ac
 SHA512:
-  metadata.gz: 3ba593790cf603ab542162e685c97450f7db2d18da76dd288981317ecf627b708a391e2b0f1eecfef43e3a308f0391a89a6bc636ab3216c6450a973d653b7e3e
-  data.tar.gz: 5c6fb87b90d197c3f70e0d69e1d5a3a13c55083aa1f8ebbd79676ff8926b12686e3fa9b2df91286ac2a216ace987863eb719b21df8693e3f0981768a2f70f748
+  metadata.gz: 0bad8e3a31fb86de2b1a2749457b506e7042606e7e060813a0adcaf81f2d0afdf8998e3ba57692fabe5814ab7efcb3dcadfb9c8e985a77b6f3c4e44aedcccf35
+  data.tar.gz: 83475ff76aae03a25c24e1b464695f68ef6b4514309e6290485e513066f3d9f4ff9367e2b87e087f89dd1f1b6b3fafa4176ca5fcae226224859356d23189a80f

data/CHANGELOG.md

@@ -1,5 +1,19 @@
 # Legion::Logging Changelog
 
+## [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
+- Structured log and exception AMQP writer headers now include `legion_protocol_version`, best-effort `x-legion-version`, and transport-standard `x-legion-identity-*` headers when process identity is resolved.
+- `log_writer` now receives the same `headers:` and `properties:` envelope metadata shape as `exception_writer`.
+
 ## [1.5.3] - 2026-05-13
 
 ### Added

data/lib/legion/logging/async_writer.rb

@@ -110,7 +110,9 @@ module Legion
         lex_name = event[:lex] || 'core'
         component = event.dig(:caller, :file).to_s[Legion::Logging::Methods::COMPONENT_REGEX, 1] || 'unknown'
         routing_key = "legion.logging.log.#{level}.#{lex_name}.#{component}"
-        Legion::Logging.log_writer.call(event, routing_key: routing_key)
+        headers    = Legion::Logging.send(:build_log_headers, event, component, level)
+        properties = Legion::Logging.send(:build_log_properties, level)
+        Legion::Logging.log_writer.call(event, routing_key: routing_key, headers: headers, properties: properties)
         Legion::Logging::Hooks.fire(level, entry.message, event) if defined?(Legion::Logging::Hooks)
       rescue StandardError => e
         warn("legion-log-writer writer error: #{e.message}")

data/lib/legion/logging/helper.rb

@@ -559,21 +559,70 @@ module Legion
 
       def build_exception_headers(event, comp, level)
         headers = {
-          '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
+          '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',

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

@@ -66,11 +66,9 @@ module Legion
         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)
+        write_async_or_sync(:fatal, formatted, raw, writer_context: build_writer_context(:fatal, raw))
       end
 
       def unknown(message = nil)
@@ -89,8 +87,20 @@ 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)
+          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
+          end
         end
       end
 
@@ -104,11 +114,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(
@@ -270,6 +281,48 @@ module Legion
         false
       end
 
+      def build_log_headers(event, component, level)
+        headers = {
+          'legion_protocol_version' => '2.0',
+          'x-component-type'        => component.to_s,
+          'x-level'                 => level.to_s
+        }
+        append_legion_version_header(headers)
+        append_optional_header(headers, 'x-lex', event[:lex])
+        append_optional_header(headers, 'x-node', event[:node])
+        append_identity_headers(headers)
+        headers
+      end
+
+      def build_log_properties(level)
+        {
+          content_type:  'application/json',
+          message_id:    SecureRandom.uuid,
+          timestamp:     Time.now.to_i,
+          app_id:        'legionio',
+          type:          'log_event',
+          priority:      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
@@ -281,17 +334,20 @@ module Legion
 
       def build_exception_headers(event, comp, level)
         headers = {
-          '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
+          '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
 
@@ -302,6 +358,28 @@ module Legion
         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',
@@ -347,7 +425,9 @@ module Legion
         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}"
-        Legion::Logging.log_writer.call(event, routing_key: routing_key)
+        headers    = build_log_headers(event, component, level)
+        properties = build_log_properties(level)
+        Legion::Logging.log_writer.call(event, routing_key: routing_key, headers: headers, properties: properties)
         Legion::Logging::Hooks.fire(level, message, event) if defined?(Legion::Logging::Hooks)
       rescue StandardError => e
         rk = defined?(routing_key) ? routing_key : 'unknown'

data/lib/legion/logging/version.rb

@@ -2,6 +2,6 @@
 
 module Legion
   module Logging
-    VERSION = '1.5.3'
+    VERSION = '1.5.5'
   end
 end

data/lib/legion/logging.rb

@@ -25,7 +25,7 @@ module Legion
       attr_reader :color
       attr_writer :log_writer, :exception_writer
 
-      DEFAULT_LOG_WRITER = ->(_event, routing_key:) {}
+      DEFAULT_LOG_WRITER = ->(_event, routing_key:, headers: nil, properties: nil) {}
       DEFAULT_EXCEPTION_WRITER = ->(_event, routing_key:, headers:, properties:) {}
 
       def log_writer

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: legion-logging
 version: !ruby/object:Gem::Version
-  version: 1.5.3
+  version: 1.5.5
 platform: ruby
 authors:
 - Esity